]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Compile fixes
[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 wxString* s = wxString_in_helper(item);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 arg1->Add(*s);
13846 delete s;
13847 Py_DECREF(item);
13848 }
13849 }
13850 {
13851 PyThreadState* __tstate = wxPyBeginAllowThreads();
13852 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13853
13854 wxPyEndAllowThreads(__tstate);
13855 if (PyErr_Occurred()) SWIG_fail;
13856 }
13857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13858 {
13859 if (temp1) delete arg1;
13860 }
13861 return resultobj;
13862 fail:
13863 {
13864 if (temp1) delete arg1;
13865 }
13866 return NULL;
13867 }
13868
13869
13870 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13871 PyObject *resultobj;
13872 wxFileTypeInfo *result;
13873 char *kwnames[] = {
13874 NULL
13875 };
13876
13877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13881
13882 wxPyEndAllowThreads(__tstate);
13883 if (PyErr_Occurred()) SWIG_fail;
13884 }
13885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13886 return resultobj;
13887 fail:
13888 return NULL;
13889 }
13890
13891
13892 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj;
13894 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13895 bool result;
13896 PyObject * obj0 = 0 ;
13897 char *kwnames[] = {
13898 (char *) "self", NULL
13899 };
13900
13901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13903 if (SWIG_arg_fail(1)) SWIG_fail;
13904 {
13905 PyThreadState* __tstate = wxPyBeginAllowThreads();
13906 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13907
13908 wxPyEndAllowThreads(__tstate);
13909 if (PyErr_Occurred()) SWIG_fail;
13910 }
13911 {
13912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13913 }
13914 return resultobj;
13915 fail:
13916 return NULL;
13917 }
13918
13919
13920 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13921 PyObject *resultobj;
13922 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13923 wxString *arg2 = 0 ;
13924 int arg3 = (int) 0 ;
13925 bool temp2 = false ;
13926 PyObject * obj0 = 0 ;
13927 PyObject * obj1 = 0 ;
13928 PyObject * obj2 = 0 ;
13929 char *kwnames[] = {
13930 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13931 };
13932
13933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13935 if (SWIG_arg_fail(1)) SWIG_fail;
13936 {
13937 arg2 = wxString_in_helper(obj1);
13938 if (arg2 == NULL) SWIG_fail;
13939 temp2 = true;
13940 }
13941 if (obj2) {
13942 {
13943 arg3 = (int)(SWIG_As_int(obj2));
13944 if (SWIG_arg_fail(3)) SWIG_fail;
13945 }
13946 }
13947 {
13948 PyThreadState* __tstate = wxPyBeginAllowThreads();
13949 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13950
13951 wxPyEndAllowThreads(__tstate);
13952 if (PyErr_Occurred()) SWIG_fail;
13953 }
13954 Py_INCREF(Py_None); resultobj = Py_None;
13955 {
13956 if (temp2)
13957 delete arg2;
13958 }
13959 return resultobj;
13960 fail:
13961 {
13962 if (temp2)
13963 delete arg2;
13964 }
13965 return NULL;
13966 }
13967
13968
13969 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13970 PyObject *resultobj;
13971 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13972 wxString *arg2 = 0 ;
13973 bool temp2 = false ;
13974 PyObject * obj0 = 0 ;
13975 PyObject * obj1 = 0 ;
13976 char *kwnames[] = {
13977 (char *) "self",(char *) "shortDesc", NULL
13978 };
13979
13980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13982 if (SWIG_arg_fail(1)) SWIG_fail;
13983 {
13984 arg2 = wxString_in_helper(obj1);
13985 if (arg2 == NULL) SWIG_fail;
13986 temp2 = true;
13987 }
13988 {
13989 PyThreadState* __tstate = wxPyBeginAllowThreads();
13990 (arg1)->SetShortDesc((wxString const &)*arg2);
13991
13992 wxPyEndAllowThreads(__tstate);
13993 if (PyErr_Occurred()) SWIG_fail;
13994 }
13995 Py_INCREF(Py_None); resultobj = Py_None;
13996 {
13997 if (temp2)
13998 delete arg2;
13999 }
14000 return resultobj;
14001 fail:
14002 {
14003 if (temp2)
14004 delete arg2;
14005 }
14006 return NULL;
14007 }
14008
14009
14010 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14011 PyObject *resultobj;
14012 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14013 wxString *result;
14014 PyObject * obj0 = 0 ;
14015 char *kwnames[] = {
14016 (char *) "self", NULL
14017 };
14018
14019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
14020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14021 if (SWIG_arg_fail(1)) SWIG_fail;
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 {
14025 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
14026 result = (wxString *) &_result_ref;
14027 }
14028
14029 wxPyEndAllowThreads(__tstate);
14030 if (PyErr_Occurred()) SWIG_fail;
14031 }
14032 {
14033 #if wxUSE_UNICODE
14034 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14035 #else
14036 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14037 #endif
14038 }
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj;
14047 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14048 wxString *result;
14049 PyObject * obj0 = 0 ;
14050 char *kwnames[] = {
14051 (char *) "self", NULL
14052 };
14053
14054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14056 if (SWIG_arg_fail(1)) SWIG_fail;
14057 {
14058 PyThreadState* __tstate = wxPyBeginAllowThreads();
14059 {
14060 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14061 result = (wxString *) &_result_ref;
14062 }
14063
14064 wxPyEndAllowThreads(__tstate);
14065 if (PyErr_Occurred()) SWIG_fail;
14066 }
14067 {
14068 #if wxUSE_UNICODE
14069 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14070 #else
14071 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14072 #endif
14073 }
14074 return resultobj;
14075 fail:
14076 return NULL;
14077 }
14078
14079
14080 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14081 PyObject *resultobj;
14082 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14083 wxString *result;
14084 PyObject * obj0 = 0 ;
14085 char *kwnames[] = {
14086 (char *) "self", NULL
14087 };
14088
14089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14091 if (SWIG_arg_fail(1)) SWIG_fail;
14092 {
14093 PyThreadState* __tstate = wxPyBeginAllowThreads();
14094 {
14095 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14096 result = (wxString *) &_result_ref;
14097 }
14098
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 {
14103 #if wxUSE_UNICODE
14104 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14105 #else
14106 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14107 #endif
14108 }
14109 return resultobj;
14110 fail:
14111 return NULL;
14112 }
14113
14114
14115 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14116 PyObject *resultobj;
14117 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14118 wxString *result;
14119 PyObject * obj0 = 0 ;
14120 char *kwnames[] = {
14121 (char *) "self", NULL
14122 };
14123
14124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14126 if (SWIG_arg_fail(1)) SWIG_fail;
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 {
14130 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14131 result = (wxString *) &_result_ref;
14132 }
14133
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 #if wxUSE_UNICODE
14139 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14140 #else
14141 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14142 #endif
14143 }
14144 return resultobj;
14145 fail:
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14153 wxString *result;
14154 PyObject * obj0 = 0 ;
14155 char *kwnames[] = {
14156 (char *) "self", NULL
14157 };
14158
14159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14161 if (SWIG_arg_fail(1)) SWIG_fail;
14162 {
14163 PyThreadState* __tstate = wxPyBeginAllowThreads();
14164 {
14165 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14166 result = (wxString *) &_result_ref;
14167 }
14168
14169 wxPyEndAllowThreads(__tstate);
14170 if (PyErr_Occurred()) SWIG_fail;
14171 }
14172 {
14173 #if wxUSE_UNICODE
14174 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14175 #else
14176 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14177 #endif
14178 }
14179 return resultobj;
14180 fail:
14181 return NULL;
14182 }
14183
14184
14185 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14186 PyObject *resultobj;
14187 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14188 wxArrayString *result;
14189 PyObject * obj0 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 {
14200 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14201 result = (wxArrayString *) &_result_ref;
14202 }
14203
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 {
14208 resultobj = wxArrayString2PyList_helper(*result);
14209 }
14210 return resultobj;
14211 fail:
14212 return NULL;
14213 }
14214
14215
14216 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14217 PyObject *resultobj;
14218 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14219 int result;
14220 PyObject * obj0 = 0 ;
14221 char *kwnames[] = {
14222 (char *) "self", NULL
14223 };
14224
14225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14227 if (SWIG_arg_fail(1)) SWIG_fail;
14228 {
14229 PyThreadState* __tstate = wxPyBeginAllowThreads();
14230 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14231
14232 wxPyEndAllowThreads(__tstate);
14233 if (PyErr_Occurred()) SWIG_fail;
14234 }
14235 {
14236 resultobj = SWIG_From_int((int)(result));
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj;
14246 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14247 wxString *result;
14248 PyObject * obj0 = 0 ;
14249 char *kwnames[] = {
14250 (char *) "self", NULL
14251 };
14252
14253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14255 if (SWIG_arg_fail(1)) SWIG_fail;
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 {
14259 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14260 result = (wxString *) &_result_ref;
14261 }
14262
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 {
14267 #if wxUSE_UNICODE
14268 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14269 #else
14270 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14271 #endif
14272 }
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14282 int result;
14283 PyObject * obj0 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 {
14299 resultobj = SWIG_From_int((int)(result));
14300 }
14301 return resultobj;
14302 fail:
14303 return NULL;
14304 }
14305
14306
14307 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14308 PyObject *obj;
14309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14310 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14311 Py_INCREF(obj);
14312 return Py_BuildValue((char *)"");
14313 }
14314 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj;
14316 wxFileTypeInfo *arg1 = 0 ;
14317 wxFileType *result;
14318 PyObject * obj0 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "ftInfo", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14324 {
14325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14326 if (SWIG_arg_fail(1)) SWIG_fail;
14327 if (arg1 == NULL) {
14328 SWIG_null_ref("wxFileTypeInfo");
14329 }
14330 if (SWIG_arg_fail(1)) SWIG_fail;
14331 }
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14335
14336 wxPyEndAllowThreads(__tstate);
14337 if (PyErr_Occurred()) SWIG_fail;
14338 }
14339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxFileType *arg1 = (wxFileType *) 0 ;
14349 PyObject * obj0 = 0 ;
14350 char *kwnames[] = {
14351 (char *) "self", NULL
14352 };
14353
14354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14356 if (SWIG_arg_fail(1)) SWIG_fail;
14357 {
14358 PyThreadState* __tstate = wxPyBeginAllowThreads();
14359 delete arg1;
14360
14361 wxPyEndAllowThreads(__tstate);
14362 if (PyErr_Occurred()) SWIG_fail;
14363 }
14364 Py_INCREF(Py_None); resultobj = Py_None;
14365 return resultobj;
14366 fail:
14367 return NULL;
14368 }
14369
14370
14371 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14372 PyObject *resultobj;
14373 wxFileType *arg1 = (wxFileType *) 0 ;
14374 PyObject *result;
14375 PyObject * obj0 = 0 ;
14376 char *kwnames[] = {
14377 (char *) "self", NULL
14378 };
14379
14380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14382 if (SWIG_arg_fail(1)) SWIG_fail;
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 result = (PyObject *)wxFileType_GetMimeType(arg1);
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 resultobj = result;
14391 return resultobj;
14392 fail:
14393 return NULL;
14394 }
14395
14396
14397 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14398 PyObject *resultobj;
14399 wxFileType *arg1 = (wxFileType *) 0 ;
14400 PyObject *result;
14401 PyObject * obj0 = 0 ;
14402 char *kwnames[] = {
14403 (char *) "self", NULL
14404 };
14405
14406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14408 if (SWIG_arg_fail(1)) SWIG_fail;
14409 {
14410 PyThreadState* __tstate = wxPyBeginAllowThreads();
14411 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14412
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 resultobj = result;
14417 return resultobj;
14418 fail:
14419 return NULL;
14420 }
14421
14422
14423 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14424 PyObject *resultobj;
14425 wxFileType *arg1 = (wxFileType *) 0 ;
14426 PyObject *result;
14427 PyObject * obj0 = 0 ;
14428 char *kwnames[] = {
14429 (char *) "self", NULL
14430 };
14431
14432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14434 if (SWIG_arg_fail(1)) SWIG_fail;
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (PyObject *)wxFileType_GetExtensions(arg1);
14438
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = result;
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14450 PyObject *resultobj;
14451 wxFileType *arg1 = (wxFileType *) 0 ;
14452 wxIcon *result;
14453 PyObject * obj0 = 0 ;
14454 char *kwnames[] = {
14455 (char *) "self", NULL
14456 };
14457
14458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14460 if (SWIG_arg_fail(1)) SWIG_fail;
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (wxIcon *)wxFileType_GetIcon(arg1);
14464
14465 wxPyEndAllowThreads(__tstate);
14466 if (PyErr_Occurred()) SWIG_fail;
14467 }
14468 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj;
14477 wxFileType *arg1 = (wxFileType *) 0 ;
14478 PyObject *result;
14479 PyObject * obj0 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 PyThreadState* __tstate = wxPyBeginAllowThreads();
14489 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14490
14491 wxPyEndAllowThreads(__tstate);
14492 if (PyErr_Occurred()) SWIG_fail;
14493 }
14494 resultobj = result;
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj;
14503 wxFileType *arg1 = (wxFileType *) 0 ;
14504 PyObject *result;
14505 PyObject * obj0 = 0 ;
14506 char *kwnames[] = {
14507 (char *) "self", NULL
14508 };
14509
14510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14512 if (SWIG_arg_fail(1)) SWIG_fail;
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 result = (PyObject *)wxFileType_GetDescription(arg1);
14516
14517 wxPyEndAllowThreads(__tstate);
14518 if (PyErr_Occurred()) SWIG_fail;
14519 }
14520 resultobj = result;
14521 return resultobj;
14522 fail:
14523 return NULL;
14524 }
14525
14526
14527 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14528 PyObject *resultobj;
14529 wxFileType *arg1 = (wxFileType *) 0 ;
14530 wxString *arg2 = 0 ;
14531 wxString const &arg3_defvalue = wxPyEmptyString ;
14532 wxString *arg3 = (wxString *) &arg3_defvalue ;
14533 PyObject *result;
14534 bool temp2 = false ;
14535 bool temp3 = false ;
14536 PyObject * obj0 = 0 ;
14537 PyObject * obj1 = 0 ;
14538 PyObject * obj2 = 0 ;
14539 char *kwnames[] = {
14540 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14541 };
14542
14543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14545 if (SWIG_arg_fail(1)) SWIG_fail;
14546 {
14547 arg2 = wxString_in_helper(obj1);
14548 if (arg2 == NULL) SWIG_fail;
14549 temp2 = true;
14550 }
14551 if (obj2) {
14552 {
14553 arg3 = wxString_in_helper(obj2);
14554 if (arg3 == NULL) SWIG_fail;
14555 temp3 = true;
14556 }
14557 }
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14561
14562 wxPyEndAllowThreads(__tstate);
14563 if (PyErr_Occurred()) SWIG_fail;
14564 }
14565 resultobj = result;
14566 {
14567 if (temp2)
14568 delete arg2;
14569 }
14570 {
14571 if (temp3)
14572 delete arg3;
14573 }
14574 return resultobj;
14575 fail:
14576 {
14577 if (temp2)
14578 delete arg2;
14579 }
14580 {
14581 if (temp3)
14582 delete arg3;
14583 }
14584 return NULL;
14585 }
14586
14587
14588 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14589 PyObject *resultobj;
14590 wxFileType *arg1 = (wxFileType *) 0 ;
14591 wxString *arg2 = 0 ;
14592 wxString const &arg3_defvalue = wxPyEmptyString ;
14593 wxString *arg3 = (wxString *) &arg3_defvalue ;
14594 PyObject *result;
14595 bool temp2 = false ;
14596 bool temp3 = false ;
14597 PyObject * obj0 = 0 ;
14598 PyObject * obj1 = 0 ;
14599 PyObject * obj2 = 0 ;
14600 char *kwnames[] = {
14601 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14602 };
14603
14604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14606 if (SWIG_arg_fail(1)) SWIG_fail;
14607 {
14608 arg2 = wxString_in_helper(obj1);
14609 if (arg2 == NULL) SWIG_fail;
14610 temp2 = true;
14611 }
14612 if (obj2) {
14613 {
14614 arg3 = wxString_in_helper(obj2);
14615 if (arg3 == NULL) SWIG_fail;
14616 temp3 = true;
14617 }
14618 }
14619 {
14620 PyThreadState* __tstate = wxPyBeginAllowThreads();
14621 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14622
14623 wxPyEndAllowThreads(__tstate);
14624 if (PyErr_Occurred()) SWIG_fail;
14625 }
14626 resultobj = result;
14627 {
14628 if (temp2)
14629 delete arg2;
14630 }
14631 {
14632 if (temp3)
14633 delete arg3;
14634 }
14635 return resultobj;
14636 fail:
14637 {
14638 if (temp2)
14639 delete arg2;
14640 }
14641 {
14642 if (temp3)
14643 delete arg3;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj;
14651 wxFileType *arg1 = (wxFileType *) 0 ;
14652 wxString *arg2 = 0 ;
14653 wxString const &arg3_defvalue = wxPyEmptyString ;
14654 wxString *arg3 = (wxString *) &arg3_defvalue ;
14655 PyObject *result;
14656 bool temp2 = false ;
14657 bool temp3 = false ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 PyObject * obj2 = 0 ;
14661 char *kwnames[] = {
14662 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14663 };
14664
14665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14667 if (SWIG_arg_fail(1)) SWIG_fail;
14668 {
14669 arg2 = wxString_in_helper(obj1);
14670 if (arg2 == NULL) SWIG_fail;
14671 temp2 = true;
14672 }
14673 if (obj2) {
14674 {
14675 arg3 = wxString_in_helper(obj2);
14676 if (arg3 == NULL) SWIG_fail;
14677 temp3 = true;
14678 }
14679 }
14680 {
14681 PyThreadState* __tstate = wxPyBeginAllowThreads();
14682 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14683
14684 wxPyEndAllowThreads(__tstate);
14685 if (PyErr_Occurred()) SWIG_fail;
14686 }
14687 resultobj = result;
14688 {
14689 if (temp2)
14690 delete arg2;
14691 }
14692 {
14693 if (temp3)
14694 delete arg3;
14695 }
14696 return resultobj;
14697 fail:
14698 {
14699 if (temp2)
14700 delete arg2;
14701 }
14702 {
14703 if (temp3)
14704 delete arg3;
14705 }
14706 return NULL;
14707 }
14708
14709
14710 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14711 PyObject *resultobj;
14712 wxFileType *arg1 = (wxFileType *) 0 ;
14713 wxString *arg2 = 0 ;
14714 wxString *arg3 = 0 ;
14715 bool arg4 = (bool) true ;
14716 bool result;
14717 bool temp2 = false ;
14718 bool temp3 = false ;
14719 PyObject * obj0 = 0 ;
14720 PyObject * obj1 = 0 ;
14721 PyObject * obj2 = 0 ;
14722 PyObject * obj3 = 0 ;
14723 char *kwnames[] = {
14724 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14725 };
14726
14727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14729 if (SWIG_arg_fail(1)) SWIG_fail;
14730 {
14731 arg2 = wxString_in_helper(obj1);
14732 if (arg2 == NULL) SWIG_fail;
14733 temp2 = true;
14734 }
14735 {
14736 arg3 = wxString_in_helper(obj2);
14737 if (arg3 == NULL) SWIG_fail;
14738 temp3 = true;
14739 }
14740 if (obj3) {
14741 {
14742 arg4 = (bool)(SWIG_As_bool(obj3));
14743 if (SWIG_arg_fail(4)) SWIG_fail;
14744 }
14745 }
14746 {
14747 PyThreadState* __tstate = wxPyBeginAllowThreads();
14748 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14749
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 {
14754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14755 }
14756 {
14757 if (temp2)
14758 delete arg2;
14759 }
14760 {
14761 if (temp3)
14762 delete arg3;
14763 }
14764 return resultobj;
14765 fail:
14766 {
14767 if (temp2)
14768 delete arg2;
14769 }
14770 {
14771 if (temp3)
14772 delete arg3;
14773 }
14774 return NULL;
14775 }
14776
14777
14778 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj;
14780 wxFileType *arg1 = (wxFileType *) 0 ;
14781 wxString const &arg2_defvalue = wxPyEmptyString ;
14782 wxString *arg2 = (wxString *) &arg2_defvalue ;
14783 int arg3 = (int) 0 ;
14784 bool result;
14785 bool temp2 = false ;
14786 PyObject * obj0 = 0 ;
14787 PyObject * obj1 = 0 ;
14788 PyObject * obj2 = 0 ;
14789 char *kwnames[] = {
14790 (char *) "self",(char *) "cmd",(char *) "index", NULL
14791 };
14792
14793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14795 if (SWIG_arg_fail(1)) SWIG_fail;
14796 if (obj1) {
14797 {
14798 arg2 = wxString_in_helper(obj1);
14799 if (arg2 == NULL) SWIG_fail;
14800 temp2 = true;
14801 }
14802 }
14803 if (obj2) {
14804 {
14805 arg3 = (int)(SWIG_As_int(obj2));
14806 if (SWIG_arg_fail(3)) SWIG_fail;
14807 }
14808 }
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14812
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 {
14817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14818 }
14819 {
14820 if (temp2)
14821 delete arg2;
14822 }
14823 return resultobj;
14824 fail:
14825 {
14826 if (temp2)
14827 delete arg2;
14828 }
14829 return NULL;
14830 }
14831
14832
14833 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14834 PyObject *resultobj;
14835 wxFileType *arg1 = (wxFileType *) 0 ;
14836 bool result;
14837 PyObject * obj0 = 0 ;
14838 char *kwnames[] = {
14839 (char *) "self", NULL
14840 };
14841
14842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14844 if (SWIG_arg_fail(1)) SWIG_fail;
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)(arg1)->Unassociate();
14848
14849 wxPyEndAllowThreads(__tstate);
14850 if (PyErr_Occurred()) SWIG_fail;
14851 }
14852 {
14853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14854 }
14855 return resultobj;
14856 fail:
14857 return NULL;
14858 }
14859
14860
14861 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj;
14863 wxString *arg1 = 0 ;
14864 wxString *arg2 = 0 ;
14865 wxString const &arg3_defvalue = wxPyEmptyString ;
14866 wxString *arg3 = (wxString *) &arg3_defvalue ;
14867 wxString result;
14868 bool temp1 = false ;
14869 bool temp2 = false ;
14870 bool temp3 = false ;
14871 PyObject * obj0 = 0 ;
14872 PyObject * obj1 = 0 ;
14873 PyObject * obj2 = 0 ;
14874 char *kwnames[] = {
14875 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14876 };
14877
14878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14879 {
14880 arg1 = wxString_in_helper(obj0);
14881 if (arg1 == NULL) SWIG_fail;
14882 temp1 = true;
14883 }
14884 {
14885 arg2 = wxString_in_helper(obj1);
14886 if (arg2 == NULL) SWIG_fail;
14887 temp2 = true;
14888 }
14889 if (obj2) {
14890 {
14891 arg3 = wxString_in_helper(obj2);
14892 if (arg3 == NULL) SWIG_fail;
14893 temp3 = true;
14894 }
14895 }
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14899
14900 wxPyEndAllowThreads(__tstate);
14901 if (PyErr_Occurred()) SWIG_fail;
14902 }
14903 {
14904 #if wxUSE_UNICODE
14905 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14906 #else
14907 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14908 #endif
14909 }
14910 {
14911 if (temp1)
14912 delete arg1;
14913 }
14914 {
14915 if (temp2)
14916 delete arg2;
14917 }
14918 {
14919 if (temp3)
14920 delete arg3;
14921 }
14922 return resultobj;
14923 fail:
14924 {
14925 if (temp1)
14926 delete arg1;
14927 }
14928 {
14929 if (temp2)
14930 delete arg2;
14931 }
14932 {
14933 if (temp3)
14934 delete arg3;
14935 }
14936 return NULL;
14937 }
14938
14939
14940 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14941 PyObject *obj;
14942 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14943 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14944 Py_INCREF(obj);
14945 return Py_BuildValue((char *)"");
14946 }
14947 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14948 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14949 return 1;
14950 }
14951
14952
14953 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14954 PyObject *pyobj;
14955
14956 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14957 return pyobj;
14958 }
14959
14960
14961 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14962 PyObject *resultobj;
14963 wxString *arg1 = 0 ;
14964 wxString *arg2 = 0 ;
14965 bool result;
14966 bool temp1 = false ;
14967 bool temp2 = false ;
14968 PyObject * obj0 = 0 ;
14969 PyObject * obj1 = 0 ;
14970 char *kwnames[] = {
14971 (char *) "mimeType",(char *) "wildcard", NULL
14972 };
14973
14974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14975 {
14976 arg1 = wxString_in_helper(obj0);
14977 if (arg1 == NULL) SWIG_fail;
14978 temp1 = true;
14979 }
14980 {
14981 arg2 = wxString_in_helper(obj1);
14982 if (arg2 == NULL) SWIG_fail;
14983 temp2 = true;
14984 }
14985 {
14986 PyThreadState* __tstate = wxPyBeginAllowThreads();
14987 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14988
14989 wxPyEndAllowThreads(__tstate);
14990 if (PyErr_Occurred()) SWIG_fail;
14991 }
14992 {
14993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14994 }
14995 {
14996 if (temp1)
14997 delete arg1;
14998 }
14999 {
15000 if (temp2)
15001 delete arg2;
15002 }
15003 return resultobj;
15004 fail:
15005 {
15006 if (temp1)
15007 delete arg1;
15008 }
15009 {
15010 if (temp2)
15011 delete arg2;
15012 }
15013 return NULL;
15014 }
15015
15016
15017 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15018 PyObject *resultobj;
15019 wxMimeTypesManager *result;
15020 char *kwnames[] = {
15021 NULL
15022 };
15023
15024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
15025 {
15026 PyThreadState* __tstate = wxPyBeginAllowThreads();
15027 result = (wxMimeTypesManager *)new wxMimeTypesManager();
15028
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
15033 return resultobj;
15034 fail:
15035 return NULL;
15036 }
15037
15038
15039 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15040 PyObject *resultobj;
15041 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15042 int arg2 = (int) wxMAILCAP_ALL ;
15043 wxString const &arg3_defvalue = wxPyEmptyString ;
15044 wxString *arg3 = (wxString *) &arg3_defvalue ;
15045 bool temp3 = false ;
15046 PyObject * obj0 = 0 ;
15047 PyObject * obj1 = 0 ;
15048 PyObject * obj2 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15055 if (SWIG_arg_fail(1)) SWIG_fail;
15056 if (obj1) {
15057 {
15058 arg2 = (int)(SWIG_As_int(obj1));
15059 if (SWIG_arg_fail(2)) SWIG_fail;
15060 }
15061 }
15062 if (obj2) {
15063 {
15064 arg3 = wxString_in_helper(obj2);
15065 if (arg3 == NULL) SWIG_fail;
15066 temp3 = true;
15067 }
15068 }
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15072
15073 wxPyEndAllowThreads(__tstate);
15074 if (PyErr_Occurred()) SWIG_fail;
15075 }
15076 Py_INCREF(Py_None); resultobj = Py_None;
15077 {
15078 if (temp3)
15079 delete arg3;
15080 }
15081 return resultobj;
15082 fail:
15083 {
15084 if (temp3)
15085 delete arg3;
15086 }
15087 return NULL;
15088 }
15089
15090
15091 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15092 PyObject *resultobj;
15093 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15094 PyObject * obj0 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 (arg1)->ClearData();
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 Py_INCREF(Py_None); resultobj = Py_None;
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15117 PyObject *resultobj;
15118 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15119 wxString *arg2 = 0 ;
15120 wxFileType *result;
15121 bool temp2 = false ;
15122 PyObject * obj0 = 0 ;
15123 PyObject * obj1 = 0 ;
15124 char *kwnames[] = {
15125 (char *) "self",(char *) "ext", NULL
15126 };
15127
15128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15130 if (SWIG_arg_fail(1)) SWIG_fail;
15131 {
15132 arg2 = wxString_in_helper(obj1);
15133 if (arg2 == NULL) SWIG_fail;
15134 temp2 = true;
15135 }
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15144 {
15145 if (temp2)
15146 delete arg2;
15147 }
15148 return resultobj;
15149 fail:
15150 {
15151 if (temp2)
15152 delete arg2;
15153 }
15154 return NULL;
15155 }
15156
15157
15158 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15159 PyObject *resultobj;
15160 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15161 wxString *arg2 = 0 ;
15162 wxFileType *result;
15163 bool temp2 = false ;
15164 PyObject * obj0 = 0 ;
15165 PyObject * obj1 = 0 ;
15166 char *kwnames[] = {
15167 (char *) "self",(char *) "mimeType", NULL
15168 };
15169
15170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15172 if (SWIG_arg_fail(1)) SWIG_fail;
15173 {
15174 arg2 = wxString_in_helper(obj1);
15175 if (arg2 == NULL) SWIG_fail;
15176 temp2 = true;
15177 }
15178 {
15179 PyThreadState* __tstate = wxPyBeginAllowThreads();
15180 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15181
15182 wxPyEndAllowThreads(__tstate);
15183 if (PyErr_Occurred()) SWIG_fail;
15184 }
15185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15186 {
15187 if (temp2)
15188 delete arg2;
15189 }
15190 return resultobj;
15191 fail:
15192 {
15193 if (temp2)
15194 delete arg2;
15195 }
15196 return NULL;
15197 }
15198
15199
15200 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15201 PyObject *resultobj;
15202 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15203 wxString *arg2 = 0 ;
15204 bool arg3 = (bool) false ;
15205 bool result;
15206 bool temp2 = false ;
15207 PyObject * obj0 = 0 ;
15208 PyObject * obj1 = 0 ;
15209 PyObject * obj2 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 arg2 = wxString_in_helper(obj1);
15219 if (arg2 == NULL) SWIG_fail;
15220 temp2 = true;
15221 }
15222 if (obj2) {
15223 {
15224 arg3 = (bool)(SWIG_As_bool(obj2));
15225 if (SWIG_arg_fail(3)) SWIG_fail;
15226 }
15227 }
15228 {
15229 PyThreadState* __tstate = wxPyBeginAllowThreads();
15230 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15231
15232 wxPyEndAllowThreads(__tstate);
15233 if (PyErr_Occurred()) SWIG_fail;
15234 }
15235 {
15236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15237 }
15238 {
15239 if (temp2)
15240 delete arg2;
15241 }
15242 return resultobj;
15243 fail:
15244 {
15245 if (temp2)
15246 delete arg2;
15247 }
15248 return NULL;
15249 }
15250
15251
15252 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj;
15254 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15255 wxString *arg2 = 0 ;
15256 bool result;
15257 bool temp2 = false ;
15258 PyObject * obj0 = 0 ;
15259 PyObject * obj1 = 0 ;
15260 char *kwnames[] = {
15261 (char *) "self",(char *) "filename", NULL
15262 };
15263
15264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15266 if (SWIG_arg_fail(1)) SWIG_fail;
15267 {
15268 arg2 = wxString_in_helper(obj1);
15269 if (arg2 == NULL) SWIG_fail;
15270 temp2 = true;
15271 }
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15275
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 {
15280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15281 }
15282 {
15283 if (temp2)
15284 delete arg2;
15285 }
15286 return resultobj;
15287 fail:
15288 {
15289 if (temp2)
15290 delete arg2;
15291 }
15292 return NULL;
15293 }
15294
15295
15296 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15297 PyObject *resultobj;
15298 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15299 PyObject *result;
15300 PyObject * obj0 = 0 ;
15301 char *kwnames[] = {
15302 (char *) "self", NULL
15303 };
15304
15305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15307 if (SWIG_arg_fail(1)) SWIG_fail;
15308 {
15309 PyThreadState* __tstate = wxPyBeginAllowThreads();
15310 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15311
15312 wxPyEndAllowThreads(__tstate);
15313 if (PyErr_Occurred()) SWIG_fail;
15314 }
15315 resultobj = result;
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj;
15324 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15325 wxFileTypeInfo *arg2 = 0 ;
15326 PyObject * obj0 = 0 ;
15327 PyObject * obj1 = 0 ;
15328 char *kwnames[] = {
15329 (char *) "self",(char *) "ft", NULL
15330 };
15331
15332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15334 if (SWIG_arg_fail(1)) SWIG_fail;
15335 {
15336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15337 if (SWIG_arg_fail(2)) SWIG_fail;
15338 if (arg2 == NULL) {
15339 SWIG_null_ref("wxFileTypeInfo");
15340 }
15341 if (SWIG_arg_fail(2)) SWIG_fail;
15342 }
15343 {
15344 PyThreadState* __tstate = wxPyBeginAllowThreads();
15345 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 Py_INCREF(Py_None); resultobj = Py_None;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15360 wxFileTypeInfo *arg2 = 0 ;
15361 wxFileType *result;
15362 PyObject * obj0 = 0 ;
15363 PyObject * obj1 = 0 ;
15364 char *kwnames[] = {
15365 (char *) "self",(char *) "ftInfo", NULL
15366 };
15367
15368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15370 if (SWIG_arg_fail(1)) SWIG_fail;
15371 {
15372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15373 if (SWIG_arg_fail(2)) SWIG_fail;
15374 if (arg2 == NULL) {
15375 SWIG_null_ref("wxFileTypeInfo");
15376 }
15377 if (SWIG_arg_fail(2)) SWIG_fail;
15378 }
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15382
15383 wxPyEndAllowThreads(__tstate);
15384 if (PyErr_Occurred()) SWIG_fail;
15385 }
15386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15387 return resultobj;
15388 fail:
15389 return NULL;
15390 }
15391
15392
15393 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15394 PyObject *resultobj;
15395 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15396 wxFileType *arg2 = (wxFileType *) 0 ;
15397 bool result;
15398 PyObject * obj0 = 0 ;
15399 PyObject * obj1 = 0 ;
15400 char *kwnames[] = {
15401 (char *) "self",(char *) "ft", NULL
15402 };
15403
15404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15406 if (SWIG_arg_fail(1)) SWIG_fail;
15407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15408 if (SWIG_arg_fail(2)) SWIG_fail;
15409 {
15410 PyThreadState* __tstate = wxPyBeginAllowThreads();
15411 result = (bool)(arg1)->Unassociate(arg2);
15412
15413 wxPyEndAllowThreads(__tstate);
15414 if (PyErr_Occurred()) SWIG_fail;
15415 }
15416 {
15417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15418 }
15419 return resultobj;
15420 fail:
15421 return NULL;
15422 }
15423
15424
15425 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15426 PyObject *resultobj;
15427 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15428 PyObject * obj0 = 0 ;
15429 char *kwnames[] = {
15430 (char *) "self", NULL
15431 };
15432
15433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15435 if (SWIG_arg_fail(1)) SWIG_fail;
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 delete arg1;
15439
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 Py_INCREF(Py_None); resultobj = Py_None;
15444 return resultobj;
15445 fail:
15446 return NULL;
15447 }
15448
15449
15450 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15451 PyObject *obj;
15452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15453 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15454 Py_INCREF(obj);
15455 return Py_BuildValue((char *)"");
15456 }
15457 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15458 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15459 return 1;
15460 }
15461
15462
15463 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15464 PyObject *pyobj;
15465
15466 {
15467 #if wxUSE_UNICODE
15468 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15469 #else
15470 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15471 #endif
15472 }
15473 return pyobj;
15474 }
15475
15476
15477 static int _wrap_ART_MENU_set(PyObject *) {
15478 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15479 return 1;
15480 }
15481
15482
15483 static PyObject *_wrap_ART_MENU_get(void) {
15484 PyObject *pyobj;
15485
15486 {
15487 #if wxUSE_UNICODE
15488 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15489 #else
15490 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15491 #endif
15492 }
15493 return pyobj;
15494 }
15495
15496
15497 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15498 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15499 return 1;
15500 }
15501
15502
15503 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15504 PyObject *pyobj;
15505
15506 {
15507 #if wxUSE_UNICODE
15508 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15509 #else
15510 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15511 #endif
15512 }
15513 return pyobj;
15514 }
15515
15516
15517 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15518 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15519 return 1;
15520 }
15521
15522
15523 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15524 PyObject *pyobj;
15525
15526 {
15527 #if wxUSE_UNICODE
15528 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15529 #else
15530 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15531 #endif
15532 }
15533 return pyobj;
15534 }
15535
15536
15537 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15538 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15539 return 1;
15540 }
15541
15542
15543 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15544 PyObject *pyobj;
15545
15546 {
15547 #if wxUSE_UNICODE
15548 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15549 #else
15550 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15551 #endif
15552 }
15553 return pyobj;
15554 }
15555
15556
15557 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15558 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15559 return 1;
15560 }
15561
15562
15563 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15564 PyObject *pyobj;
15565
15566 {
15567 #if wxUSE_UNICODE
15568 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15569 #else
15570 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15571 #endif
15572 }
15573 return pyobj;
15574 }
15575
15576
15577 static int _wrap_ART_BUTTON_set(PyObject *) {
15578 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15579 return 1;
15580 }
15581
15582
15583 static PyObject *_wrap_ART_BUTTON_get(void) {
15584 PyObject *pyobj;
15585
15586 {
15587 #if wxUSE_UNICODE
15588 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15589 #else
15590 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15591 #endif
15592 }
15593 return pyobj;
15594 }
15595
15596
15597 static int _wrap_ART_OTHER_set(PyObject *) {
15598 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15599 return 1;
15600 }
15601
15602
15603 static PyObject *_wrap_ART_OTHER_get(void) {
15604 PyObject *pyobj;
15605
15606 {
15607 #if wxUSE_UNICODE
15608 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15609 #else
15610 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15611 #endif
15612 }
15613 return pyobj;
15614 }
15615
15616
15617 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15618 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15619 return 1;
15620 }
15621
15622
15623 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15624 PyObject *pyobj;
15625
15626 {
15627 #if wxUSE_UNICODE
15628 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15629 #else
15630 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15631 #endif
15632 }
15633 return pyobj;
15634 }
15635
15636
15637 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15638 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15639 return 1;
15640 }
15641
15642
15643 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15644 PyObject *pyobj;
15645
15646 {
15647 #if wxUSE_UNICODE
15648 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15649 #else
15650 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15651 #endif
15652 }
15653 return pyobj;
15654 }
15655
15656
15657 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15658 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15659 return 1;
15660 }
15661
15662
15663 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15664 PyObject *pyobj;
15665
15666 {
15667 #if wxUSE_UNICODE
15668 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15669 #else
15670 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15671 #endif
15672 }
15673 return pyobj;
15674 }
15675
15676
15677 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15678 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15679 return 1;
15680 }
15681
15682
15683 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15684 PyObject *pyobj;
15685
15686 {
15687 #if wxUSE_UNICODE
15688 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15689 #else
15690 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15691 #endif
15692 }
15693 return pyobj;
15694 }
15695
15696
15697 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15698 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15699 return 1;
15700 }
15701
15702
15703 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15704 PyObject *pyobj;
15705
15706 {
15707 #if wxUSE_UNICODE
15708 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15709 #else
15710 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15711 #endif
15712 }
15713 return pyobj;
15714 }
15715
15716
15717 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15718 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15719 return 1;
15720 }
15721
15722
15723 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15724 PyObject *pyobj;
15725
15726 {
15727 #if wxUSE_UNICODE
15728 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15729 #else
15730 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15731 #endif
15732 }
15733 return pyobj;
15734 }
15735
15736
15737 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15738 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15739 return 1;
15740 }
15741
15742
15743 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15744 PyObject *pyobj;
15745
15746 {
15747 #if wxUSE_UNICODE
15748 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15749 #else
15750 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15751 #endif
15752 }
15753 return pyobj;
15754 }
15755
15756
15757 static int _wrap_ART_GO_BACK_set(PyObject *) {
15758 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15759 return 1;
15760 }
15761
15762
15763 static PyObject *_wrap_ART_GO_BACK_get(void) {
15764 PyObject *pyobj;
15765
15766 {
15767 #if wxUSE_UNICODE
15768 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15769 #else
15770 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15771 #endif
15772 }
15773 return pyobj;
15774 }
15775
15776
15777 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15778 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15779 return 1;
15780 }
15781
15782
15783 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15784 PyObject *pyobj;
15785
15786 {
15787 #if wxUSE_UNICODE
15788 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15789 #else
15790 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15791 #endif
15792 }
15793 return pyobj;
15794 }
15795
15796
15797 static int _wrap_ART_GO_UP_set(PyObject *) {
15798 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15799 return 1;
15800 }
15801
15802
15803 static PyObject *_wrap_ART_GO_UP_get(void) {
15804 PyObject *pyobj;
15805
15806 {
15807 #if wxUSE_UNICODE
15808 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15809 #else
15810 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15811 #endif
15812 }
15813 return pyobj;
15814 }
15815
15816
15817 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15818 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15819 return 1;
15820 }
15821
15822
15823 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15824 PyObject *pyobj;
15825
15826 {
15827 #if wxUSE_UNICODE
15828 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15829 #else
15830 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15831 #endif
15832 }
15833 return pyobj;
15834 }
15835
15836
15837 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15838 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15839 return 1;
15840 }
15841
15842
15843 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15844 PyObject *pyobj;
15845
15846 {
15847 #if wxUSE_UNICODE
15848 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15849 #else
15850 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15851 #endif
15852 }
15853 return pyobj;
15854 }
15855
15856
15857 static int _wrap_ART_GO_HOME_set(PyObject *) {
15858 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15859 return 1;
15860 }
15861
15862
15863 static PyObject *_wrap_ART_GO_HOME_get(void) {
15864 PyObject *pyobj;
15865
15866 {
15867 #if wxUSE_UNICODE
15868 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15869 #else
15870 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15871 #endif
15872 }
15873 return pyobj;
15874 }
15875
15876
15877 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15878 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15879 return 1;
15880 }
15881
15882
15883 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15884 PyObject *pyobj;
15885
15886 {
15887 #if wxUSE_UNICODE
15888 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15889 #else
15890 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15891 #endif
15892 }
15893 return pyobj;
15894 }
15895
15896
15897 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15898 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15899 return 1;
15900 }
15901
15902
15903 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15904 PyObject *pyobj;
15905
15906 {
15907 #if wxUSE_UNICODE
15908 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15909 #else
15910 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15911 #endif
15912 }
15913 return pyobj;
15914 }
15915
15916
15917 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15918 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15919 return 1;
15920 }
15921
15922
15923 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15924 PyObject *pyobj;
15925
15926 {
15927 #if wxUSE_UNICODE
15928 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15929 #else
15930 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15931 #endif
15932 }
15933 return pyobj;
15934 }
15935
15936
15937 static int _wrap_ART_PRINT_set(PyObject *) {
15938 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15939 return 1;
15940 }
15941
15942
15943 static PyObject *_wrap_ART_PRINT_get(void) {
15944 PyObject *pyobj;
15945
15946 {
15947 #if wxUSE_UNICODE
15948 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15949 #else
15950 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15951 #endif
15952 }
15953 return pyobj;
15954 }
15955
15956
15957 static int _wrap_ART_HELP_set(PyObject *) {
15958 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15959 return 1;
15960 }
15961
15962
15963 static PyObject *_wrap_ART_HELP_get(void) {
15964 PyObject *pyobj;
15965
15966 {
15967 #if wxUSE_UNICODE
15968 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15969 #else
15970 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15971 #endif
15972 }
15973 return pyobj;
15974 }
15975
15976
15977 static int _wrap_ART_TIP_set(PyObject *) {
15978 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15979 return 1;
15980 }
15981
15982
15983 static PyObject *_wrap_ART_TIP_get(void) {
15984 PyObject *pyobj;
15985
15986 {
15987 #if wxUSE_UNICODE
15988 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15989 #else
15990 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15991 #endif
15992 }
15993 return pyobj;
15994 }
15995
15996
15997 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15998 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15999 return 1;
16000 }
16001
16002
16003 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
16004 PyObject *pyobj;
16005
16006 {
16007 #if wxUSE_UNICODE
16008 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16009 #else
16010 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
16011 #endif
16012 }
16013 return pyobj;
16014 }
16015
16016
16017 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
16018 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
16019 return 1;
16020 }
16021
16022
16023 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
16024 PyObject *pyobj;
16025
16026 {
16027 #if wxUSE_UNICODE
16028 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16029 #else
16030 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
16031 #endif
16032 }
16033 return pyobj;
16034 }
16035
16036
16037 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16038 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16039 return 1;
16040 }
16041
16042
16043 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16044 PyObject *pyobj;
16045
16046 {
16047 #if wxUSE_UNICODE
16048 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16049 #else
16050 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16051 #endif
16052 }
16053 return pyobj;
16054 }
16055
16056
16057 static int _wrap_ART_HARDDISK_set(PyObject *) {
16058 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16059 return 1;
16060 }
16061
16062
16063 static PyObject *_wrap_ART_HARDDISK_get(void) {
16064 PyObject *pyobj;
16065
16066 {
16067 #if wxUSE_UNICODE
16068 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16069 #else
16070 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16071 #endif
16072 }
16073 return pyobj;
16074 }
16075
16076
16077 static int _wrap_ART_FLOPPY_set(PyObject *) {
16078 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16079 return 1;
16080 }
16081
16082
16083 static PyObject *_wrap_ART_FLOPPY_get(void) {
16084 PyObject *pyobj;
16085
16086 {
16087 #if wxUSE_UNICODE
16088 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16089 #else
16090 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16091 #endif
16092 }
16093 return pyobj;
16094 }
16095
16096
16097 static int _wrap_ART_CDROM_set(PyObject *) {
16098 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16099 return 1;
16100 }
16101
16102
16103 static PyObject *_wrap_ART_CDROM_get(void) {
16104 PyObject *pyobj;
16105
16106 {
16107 #if wxUSE_UNICODE
16108 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16109 #else
16110 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16111 #endif
16112 }
16113 return pyobj;
16114 }
16115
16116
16117 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16118 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16119 return 1;
16120 }
16121
16122
16123 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16124 PyObject *pyobj;
16125
16126 {
16127 #if wxUSE_UNICODE
16128 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16129 #else
16130 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16131 #endif
16132 }
16133 return pyobj;
16134 }
16135
16136
16137 static int _wrap_ART_FOLDER_set(PyObject *) {
16138 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16139 return 1;
16140 }
16141
16142
16143 static PyObject *_wrap_ART_FOLDER_get(void) {
16144 PyObject *pyobj;
16145
16146 {
16147 #if wxUSE_UNICODE
16148 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16149 #else
16150 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16151 #endif
16152 }
16153 return pyobj;
16154 }
16155
16156
16157 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16158 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16159 return 1;
16160 }
16161
16162
16163 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16164 PyObject *pyobj;
16165
16166 {
16167 #if wxUSE_UNICODE
16168 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16169 #else
16170 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16171 #endif
16172 }
16173 return pyobj;
16174 }
16175
16176
16177 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16178 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16179 return 1;
16180 }
16181
16182
16183 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16184 PyObject *pyobj;
16185
16186 {
16187 #if wxUSE_UNICODE
16188 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16189 #else
16190 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16191 #endif
16192 }
16193 return pyobj;
16194 }
16195
16196
16197 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16198 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16199 return 1;
16200 }
16201
16202
16203 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16204 PyObject *pyobj;
16205
16206 {
16207 #if wxUSE_UNICODE
16208 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16209 #else
16210 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16211 #endif
16212 }
16213 return pyobj;
16214 }
16215
16216
16217 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16218 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16219 return 1;
16220 }
16221
16222
16223 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16224 PyObject *pyobj;
16225
16226 {
16227 #if wxUSE_UNICODE
16228 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16229 #else
16230 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16231 #endif
16232 }
16233 return pyobj;
16234 }
16235
16236
16237 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16238 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16239 return 1;
16240 }
16241
16242
16243 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16244 PyObject *pyobj;
16245
16246 {
16247 #if wxUSE_UNICODE
16248 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16249 #else
16250 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16251 #endif
16252 }
16253 return pyobj;
16254 }
16255
16256
16257 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16258 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16259 return 1;
16260 }
16261
16262
16263 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16264 PyObject *pyobj;
16265
16266 {
16267 #if wxUSE_UNICODE
16268 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16269 #else
16270 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16271 #endif
16272 }
16273 return pyobj;
16274 }
16275
16276
16277 static int _wrap_ART_ERROR_set(PyObject *) {
16278 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16279 return 1;
16280 }
16281
16282
16283 static PyObject *_wrap_ART_ERROR_get(void) {
16284 PyObject *pyobj;
16285
16286 {
16287 #if wxUSE_UNICODE
16288 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16289 #else
16290 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16291 #endif
16292 }
16293 return pyobj;
16294 }
16295
16296
16297 static int _wrap_ART_QUESTION_set(PyObject *) {
16298 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16299 return 1;
16300 }
16301
16302
16303 static PyObject *_wrap_ART_QUESTION_get(void) {
16304 PyObject *pyobj;
16305
16306 {
16307 #if wxUSE_UNICODE
16308 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16309 #else
16310 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16311 #endif
16312 }
16313 return pyobj;
16314 }
16315
16316
16317 static int _wrap_ART_WARNING_set(PyObject *) {
16318 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16319 return 1;
16320 }
16321
16322
16323 static PyObject *_wrap_ART_WARNING_get(void) {
16324 PyObject *pyobj;
16325
16326 {
16327 #if wxUSE_UNICODE
16328 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16329 #else
16330 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16331 #endif
16332 }
16333 return pyobj;
16334 }
16335
16336
16337 static int _wrap_ART_INFORMATION_set(PyObject *) {
16338 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16339 return 1;
16340 }
16341
16342
16343 static PyObject *_wrap_ART_INFORMATION_get(void) {
16344 PyObject *pyobj;
16345
16346 {
16347 #if wxUSE_UNICODE
16348 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16349 #else
16350 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16351 #endif
16352 }
16353 return pyobj;
16354 }
16355
16356
16357 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16358 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16359 return 1;
16360 }
16361
16362
16363 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16364 PyObject *pyobj;
16365
16366 {
16367 #if wxUSE_UNICODE
16368 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16369 #else
16370 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16371 #endif
16372 }
16373 return pyobj;
16374 }
16375
16376
16377 static int _wrap_ART_COPY_set(PyObject *) {
16378 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16379 return 1;
16380 }
16381
16382
16383 static PyObject *_wrap_ART_COPY_get(void) {
16384 PyObject *pyobj;
16385
16386 {
16387 #if wxUSE_UNICODE
16388 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16389 #else
16390 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16391 #endif
16392 }
16393 return pyobj;
16394 }
16395
16396
16397 static int _wrap_ART_CUT_set(PyObject *) {
16398 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16399 return 1;
16400 }
16401
16402
16403 static PyObject *_wrap_ART_CUT_get(void) {
16404 PyObject *pyobj;
16405
16406 {
16407 #if wxUSE_UNICODE
16408 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16409 #else
16410 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16411 #endif
16412 }
16413 return pyobj;
16414 }
16415
16416
16417 static int _wrap_ART_PASTE_set(PyObject *) {
16418 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16419 return 1;
16420 }
16421
16422
16423 static PyObject *_wrap_ART_PASTE_get(void) {
16424 PyObject *pyobj;
16425
16426 {
16427 #if wxUSE_UNICODE
16428 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16429 #else
16430 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16431 #endif
16432 }
16433 return pyobj;
16434 }
16435
16436
16437 static int _wrap_ART_DELETE_set(PyObject *) {
16438 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16439 return 1;
16440 }
16441
16442
16443 static PyObject *_wrap_ART_DELETE_get(void) {
16444 PyObject *pyobj;
16445
16446 {
16447 #if wxUSE_UNICODE
16448 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16449 #else
16450 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16451 #endif
16452 }
16453 return pyobj;
16454 }
16455
16456
16457 static int _wrap_ART_UNDO_set(PyObject *) {
16458 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16459 return 1;
16460 }
16461
16462
16463 static PyObject *_wrap_ART_UNDO_get(void) {
16464 PyObject *pyobj;
16465
16466 {
16467 #if wxUSE_UNICODE
16468 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16469 #else
16470 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16471 #endif
16472 }
16473 return pyobj;
16474 }
16475
16476
16477 static int _wrap_ART_REDO_set(PyObject *) {
16478 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16479 return 1;
16480 }
16481
16482
16483 static PyObject *_wrap_ART_REDO_get(void) {
16484 PyObject *pyobj;
16485
16486 {
16487 #if wxUSE_UNICODE
16488 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16489 #else
16490 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16491 #endif
16492 }
16493 return pyobj;
16494 }
16495
16496
16497 static int _wrap_ART_QUIT_set(PyObject *) {
16498 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16499 return 1;
16500 }
16501
16502
16503 static PyObject *_wrap_ART_QUIT_get(void) {
16504 PyObject *pyobj;
16505
16506 {
16507 #if wxUSE_UNICODE
16508 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16509 #else
16510 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16511 #endif
16512 }
16513 return pyobj;
16514 }
16515
16516
16517 static int _wrap_ART_FIND_set(PyObject *) {
16518 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16519 return 1;
16520 }
16521
16522
16523 static PyObject *_wrap_ART_FIND_get(void) {
16524 PyObject *pyobj;
16525
16526 {
16527 #if wxUSE_UNICODE
16528 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16529 #else
16530 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16531 #endif
16532 }
16533 return pyobj;
16534 }
16535
16536
16537 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16538 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16539 return 1;
16540 }
16541
16542
16543 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16544 PyObject *pyobj;
16545
16546 {
16547 #if wxUSE_UNICODE
16548 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16549 #else
16550 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16551 #endif
16552 }
16553 return pyobj;
16554 }
16555
16556
16557 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj;
16559 wxPyArtProvider *result;
16560 char *kwnames[] = {
16561 NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16565 {
16566 if (!wxPyCheckForApp()) SWIG_fail;
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (wxPyArtProvider *)new wxPyArtProvider();
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16574 return resultobj;
16575 fail:
16576 return NULL;
16577 }
16578
16579
16580 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16581 PyObject *resultobj;
16582 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16583 PyObject *arg2 = (PyObject *) 0 ;
16584 PyObject *arg3 = (PyObject *) 0 ;
16585 PyObject * obj0 = 0 ;
16586 PyObject * obj1 = 0 ;
16587 PyObject * obj2 = 0 ;
16588 char *kwnames[] = {
16589 (char *) "self",(char *) "self",(char *) "_class", NULL
16590 };
16591
16592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16594 if (SWIG_arg_fail(1)) SWIG_fail;
16595 arg2 = obj1;
16596 arg3 = obj2;
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 (arg1)->_setCallbackInfo(arg2,arg3);
16600
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 Py_INCREF(Py_None); resultobj = Py_None;
16605 return resultobj;
16606 fail:
16607 return NULL;
16608 }
16609
16610
16611 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16612 PyObject *resultobj;
16613 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16614 PyObject * obj0 = 0 ;
16615 char *kwnames[] = {
16616 (char *) "provider", NULL
16617 };
16618
16619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16621 if (SWIG_arg_fail(1)) SWIG_fail;
16622 {
16623 PyThreadState* __tstate = wxPyBeginAllowThreads();
16624 wxPyArtProvider::PushProvider(arg1);
16625
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 Py_INCREF(Py_None); resultobj = Py_None;
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj;
16638 bool result;
16639 char *kwnames[] = {
16640 NULL
16641 };
16642
16643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (bool)wxPyArtProvider::PopProvider();
16647
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16653 }
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj;
16662 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16663 bool result;
16664 PyObject * obj0 = 0 ;
16665 char *kwnames[] = {
16666 (char *) "provider", NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16671 if (SWIG_arg_fail(1)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16675
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 {
16680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16681 }
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj;
16690 wxString *arg1 = 0 ;
16691 wxString const &arg2_defvalue = wxPyART_OTHER ;
16692 wxString *arg2 = (wxString *) &arg2_defvalue ;
16693 wxSize const &arg3_defvalue = wxDefaultSize ;
16694 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16695 wxBitmap result;
16696 bool temp1 = false ;
16697 bool temp2 = false ;
16698 wxSize temp3 ;
16699 PyObject * obj0 = 0 ;
16700 PyObject * obj1 = 0 ;
16701 PyObject * obj2 = 0 ;
16702 char *kwnames[] = {
16703 (char *) "id",(char *) "client",(char *) "size", NULL
16704 };
16705
16706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16707 {
16708 arg1 = wxString_in_helper(obj0);
16709 if (arg1 == NULL) SWIG_fail;
16710 temp1 = true;
16711 }
16712 if (obj1) {
16713 {
16714 arg2 = wxString_in_helper(obj1);
16715 if (arg2 == NULL) SWIG_fail;
16716 temp2 = true;
16717 }
16718 }
16719 if (obj2) {
16720 {
16721 arg3 = &temp3;
16722 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16723 }
16724 }
16725 {
16726 if (!wxPyCheckForApp()) SWIG_fail;
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16729
16730 wxPyEndAllowThreads(__tstate);
16731 if (PyErr_Occurred()) SWIG_fail;
16732 }
16733 {
16734 wxBitmap * resultptr;
16735 resultptr = new wxBitmap((wxBitmap &)(result));
16736 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16737 }
16738 {
16739 if (temp1)
16740 delete arg1;
16741 }
16742 {
16743 if (temp2)
16744 delete arg2;
16745 }
16746 return resultobj;
16747 fail:
16748 {
16749 if (temp1)
16750 delete arg1;
16751 }
16752 {
16753 if (temp2)
16754 delete arg2;
16755 }
16756 return NULL;
16757 }
16758
16759
16760 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16761 PyObject *resultobj;
16762 wxString *arg1 = 0 ;
16763 wxString const &arg2_defvalue = wxPyART_OTHER ;
16764 wxString *arg2 = (wxString *) &arg2_defvalue ;
16765 wxSize const &arg3_defvalue = wxDefaultSize ;
16766 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16767 wxIcon result;
16768 bool temp1 = false ;
16769 bool temp2 = false ;
16770 wxSize temp3 ;
16771 PyObject * obj0 = 0 ;
16772 PyObject * obj1 = 0 ;
16773 PyObject * obj2 = 0 ;
16774 char *kwnames[] = {
16775 (char *) "id",(char *) "client",(char *) "size", NULL
16776 };
16777
16778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16779 {
16780 arg1 = wxString_in_helper(obj0);
16781 if (arg1 == NULL) SWIG_fail;
16782 temp1 = true;
16783 }
16784 if (obj1) {
16785 {
16786 arg2 = wxString_in_helper(obj1);
16787 if (arg2 == NULL) SWIG_fail;
16788 temp2 = true;
16789 }
16790 }
16791 if (obj2) {
16792 {
16793 arg3 = &temp3;
16794 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16795 }
16796 }
16797 {
16798 if (!wxPyCheckForApp()) SWIG_fail;
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16801
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 {
16806 wxIcon * resultptr;
16807 resultptr = new wxIcon((wxIcon &)(result));
16808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16809 }
16810 {
16811 if (temp1)
16812 delete arg1;
16813 }
16814 {
16815 if (temp2)
16816 delete arg2;
16817 }
16818 return resultobj;
16819 fail:
16820 {
16821 if (temp1)
16822 delete arg1;
16823 }
16824 {
16825 if (temp2)
16826 delete arg2;
16827 }
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 wxString *arg1 = 0 ;
16835 bool arg2 = (bool) false ;
16836 wxSize result;
16837 bool temp1 = false ;
16838 PyObject * obj0 = 0 ;
16839 PyObject * obj1 = 0 ;
16840 char *kwnames[] = {
16841 (char *) "client",(char *) "platform_dependent", NULL
16842 };
16843
16844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16845 {
16846 arg1 = wxString_in_helper(obj0);
16847 if (arg1 == NULL) SWIG_fail;
16848 temp1 = true;
16849 }
16850 if (obj1) {
16851 {
16852 arg2 = (bool)(SWIG_As_bool(obj1));
16853 if (SWIG_arg_fail(2)) SWIG_fail;
16854 }
16855 }
16856 {
16857 PyThreadState* __tstate = wxPyBeginAllowThreads();
16858 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16859
16860 wxPyEndAllowThreads(__tstate);
16861 if (PyErr_Occurred()) SWIG_fail;
16862 }
16863 {
16864 wxSize * resultptr;
16865 resultptr = new wxSize((wxSize &)(result));
16866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16867 }
16868 {
16869 if (temp1)
16870 delete arg1;
16871 }
16872 return resultobj;
16873 fail:
16874 {
16875 if (temp1)
16876 delete arg1;
16877 }
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj;
16884 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16885 PyObject * obj0 = 0 ;
16886 char *kwnames[] = {
16887 (char *) "self", NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16892 if (SWIG_arg_fail(1)) SWIG_fail;
16893 {
16894 PyThreadState* __tstate = wxPyBeginAllowThreads();
16895 wxPyArtProvider_Destroy(arg1);
16896
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 Py_INCREF(Py_None); resultobj = Py_None;
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16908 PyObject *obj;
16909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16910 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16911 Py_INCREF(obj);
16912 return Py_BuildValue((char *)"");
16913 }
16914 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16915 PyObject *resultobj;
16916 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "self", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16924 if (SWIG_arg_fail(1)) SWIG_fail;
16925 {
16926 PyThreadState* __tstate = wxPyBeginAllowThreads();
16927 delete arg1;
16928
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 Py_INCREF(Py_None); resultobj = Py_None;
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj;
16941 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16942 wxConfigBase *result;
16943 PyObject * obj0 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "config", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 PyThreadState* __tstate = wxPyBeginAllowThreads();
16953 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16954
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16959 return resultobj;
16960 fail:
16961 return NULL;
16962 }
16963
16964
16965 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16966 PyObject *resultobj;
16967 bool arg1 = (bool) true ;
16968 wxConfigBase *result;
16969 PyObject * obj0 = 0 ;
16970 char *kwnames[] = {
16971 (char *) "createOnDemand", NULL
16972 };
16973
16974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16975 if (obj0) {
16976 {
16977 arg1 = (bool)(SWIG_As_bool(obj0));
16978 if (SWIG_arg_fail(1)) SWIG_fail;
16979 }
16980 }
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16984
16985 wxPyEndAllowThreads(__tstate);
16986 if (PyErr_Occurred()) SWIG_fail;
16987 }
16988 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16989 return resultobj;
16990 fail:
16991 return NULL;
16992 }
16993
16994
16995 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16996 PyObject *resultobj;
16997 wxConfigBase *result;
16998 char *kwnames[] = {
16999 NULL
17000 };
17001
17002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
17003 {
17004 PyThreadState* __tstate = wxPyBeginAllowThreads();
17005 result = (wxConfigBase *)wxConfigBase::Create();
17006
17007 wxPyEndAllowThreads(__tstate);
17008 if (PyErr_Occurred()) SWIG_fail;
17009 }
17010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj;
17019 char *kwnames[] = {
17020 NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
17024 {
17025 PyThreadState* __tstate = wxPyBeginAllowThreads();
17026 wxConfigBase::DontCreateOnDemand();
17027
17028 wxPyEndAllowThreads(__tstate);
17029 if (PyErr_Occurred()) SWIG_fail;
17030 }
17031 Py_INCREF(Py_None); resultobj = Py_None;
17032 return resultobj;
17033 fail:
17034 return NULL;
17035 }
17036
17037
17038 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17039 PyObject *resultobj;
17040 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17041 wxString *arg2 = 0 ;
17042 bool temp2 = false ;
17043 PyObject * obj0 = 0 ;
17044 PyObject * obj1 = 0 ;
17045 char *kwnames[] = {
17046 (char *) "self",(char *) "path", NULL
17047 };
17048
17049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17051 if (SWIG_arg_fail(1)) SWIG_fail;
17052 {
17053 arg2 = wxString_in_helper(obj1);
17054 if (arg2 == NULL) SWIG_fail;
17055 temp2 = true;
17056 }
17057 {
17058 PyThreadState* __tstate = wxPyBeginAllowThreads();
17059 (arg1)->SetPath((wxString const &)*arg2);
17060
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 Py_INCREF(Py_None); resultobj = Py_None;
17065 {
17066 if (temp2)
17067 delete arg2;
17068 }
17069 return resultobj;
17070 fail:
17071 {
17072 if (temp2)
17073 delete arg2;
17074 }
17075 return NULL;
17076 }
17077
17078
17079 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17080 PyObject *resultobj;
17081 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17082 wxString *result;
17083 PyObject * obj0 = 0 ;
17084 char *kwnames[] = {
17085 (char *) "self", NULL
17086 };
17087
17088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17090 if (SWIG_arg_fail(1)) SWIG_fail;
17091 {
17092 PyThreadState* __tstate = wxPyBeginAllowThreads();
17093 {
17094 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17095 result = (wxString *) &_result_ref;
17096 }
17097
17098 wxPyEndAllowThreads(__tstate);
17099 if (PyErr_Occurred()) SWIG_fail;
17100 }
17101 {
17102 #if wxUSE_UNICODE
17103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17104 #else
17105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17106 #endif
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj;
17116 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17117 PyObject *result;
17118 PyObject * obj0 = 0 ;
17119 char *kwnames[] = {
17120 (char *) "self", NULL
17121 };
17122
17123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17125 if (SWIG_arg_fail(1)) SWIG_fail;
17126 {
17127 PyThreadState* __tstate = wxPyBeginAllowThreads();
17128 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17129
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 resultobj = result;
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj;
17142 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17143 long arg2 ;
17144 PyObject *result;
17145 PyObject * obj0 = 0 ;
17146 PyObject * obj1 = 0 ;
17147 char *kwnames[] = {
17148 (char *) "self",(char *) "index", NULL
17149 };
17150
17151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17153 if (SWIG_arg_fail(1)) SWIG_fail;
17154 {
17155 arg2 = (long)(SWIG_As_long(obj1));
17156 if (SWIG_arg_fail(2)) SWIG_fail;
17157 }
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17161
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 resultobj = result;
17166 return resultobj;
17167 fail:
17168 return NULL;
17169 }
17170
17171
17172 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17173 PyObject *resultobj;
17174 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17175 PyObject *result;
17176 PyObject * obj0 = 0 ;
17177 char *kwnames[] = {
17178 (char *) "self", NULL
17179 };
17180
17181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17183 if (SWIG_arg_fail(1)) SWIG_fail;
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17187
17188 wxPyEndAllowThreads(__tstate);
17189 if (PyErr_Occurred()) SWIG_fail;
17190 }
17191 resultobj = result;
17192 return resultobj;
17193 fail:
17194 return NULL;
17195 }
17196
17197
17198 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17199 PyObject *resultobj;
17200 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17201 long arg2 ;
17202 PyObject *result;
17203 PyObject * obj0 = 0 ;
17204 PyObject * obj1 = 0 ;
17205 char *kwnames[] = {
17206 (char *) "self",(char *) "index", NULL
17207 };
17208
17209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17211 if (SWIG_arg_fail(1)) SWIG_fail;
17212 {
17213 arg2 = (long)(SWIG_As_long(obj1));
17214 if (SWIG_arg_fail(2)) SWIG_fail;
17215 }
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17219
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 resultobj = result;
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17231 PyObject *resultobj;
17232 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17233 bool arg2 = (bool) false ;
17234 size_t result;
17235 PyObject * obj0 = 0 ;
17236 PyObject * obj1 = 0 ;
17237 char *kwnames[] = {
17238 (char *) "self",(char *) "recursive", NULL
17239 };
17240
17241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17243 if (SWIG_arg_fail(1)) SWIG_fail;
17244 if (obj1) {
17245 {
17246 arg2 = (bool)(SWIG_As_bool(obj1));
17247 if (SWIG_arg_fail(2)) SWIG_fail;
17248 }
17249 }
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17253
17254 wxPyEndAllowThreads(__tstate);
17255 if (PyErr_Occurred()) SWIG_fail;
17256 }
17257 {
17258 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17259 }
17260 return resultobj;
17261 fail:
17262 return NULL;
17263 }
17264
17265
17266 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17269 bool arg2 = (bool) false ;
17270 size_t result;
17271 PyObject * obj0 = 0 ;
17272 PyObject * obj1 = 0 ;
17273 char *kwnames[] = {
17274 (char *) "self",(char *) "recursive", NULL
17275 };
17276
17277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17279 if (SWIG_arg_fail(1)) SWIG_fail;
17280 if (obj1) {
17281 {
17282 arg2 = (bool)(SWIG_As_bool(obj1));
17283 if (SWIG_arg_fail(2)) SWIG_fail;
17284 }
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17289
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 {
17294 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17295 }
17296 return resultobj;
17297 fail:
17298 return NULL;
17299 }
17300
17301
17302 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17303 PyObject *resultobj;
17304 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17305 wxString *arg2 = 0 ;
17306 bool result;
17307 bool temp2 = false ;
17308 PyObject * obj0 = 0 ;
17309 PyObject * obj1 = 0 ;
17310 char *kwnames[] = {
17311 (char *) "self",(char *) "name", NULL
17312 };
17313
17314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17316 if (SWIG_arg_fail(1)) SWIG_fail;
17317 {
17318 arg2 = wxString_in_helper(obj1);
17319 if (arg2 == NULL) SWIG_fail;
17320 temp2 = true;
17321 }
17322 {
17323 PyThreadState* __tstate = wxPyBeginAllowThreads();
17324 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17325
17326 wxPyEndAllowThreads(__tstate);
17327 if (PyErr_Occurred()) SWIG_fail;
17328 }
17329 {
17330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17331 }
17332 {
17333 if (temp2)
17334 delete arg2;
17335 }
17336 return resultobj;
17337 fail:
17338 {
17339 if (temp2)
17340 delete arg2;
17341 }
17342 return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj;
17348 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17349 wxString *arg2 = 0 ;
17350 bool result;
17351 bool temp2 = false ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 char *kwnames[] = {
17355 (char *) "self",(char *) "name", NULL
17356 };
17357
17358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17360 if (SWIG_arg_fail(1)) SWIG_fail;
17361 {
17362 arg2 = wxString_in_helper(obj1);
17363 if (arg2 == NULL) SWIG_fail;
17364 temp2 = true;
17365 }
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17369
17370 wxPyEndAllowThreads(__tstate);
17371 if (PyErr_Occurred()) SWIG_fail;
17372 }
17373 {
17374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17375 }
17376 {
17377 if (temp2)
17378 delete arg2;
17379 }
17380 return resultobj;
17381 fail:
17382 {
17383 if (temp2)
17384 delete arg2;
17385 }
17386 return NULL;
17387 }
17388
17389
17390 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj;
17392 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17393 wxString *arg2 = 0 ;
17394 bool result;
17395 bool temp2 = false ;
17396 PyObject * obj0 = 0 ;
17397 PyObject * obj1 = 0 ;
17398 char *kwnames[] = {
17399 (char *) "self",(char *) "name", NULL
17400 };
17401
17402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17404 if (SWIG_arg_fail(1)) SWIG_fail;
17405 {
17406 arg2 = wxString_in_helper(obj1);
17407 if (arg2 == NULL) SWIG_fail;
17408 temp2 = true;
17409 }
17410 {
17411 PyThreadState* __tstate = wxPyBeginAllowThreads();
17412 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17413
17414 wxPyEndAllowThreads(__tstate);
17415 if (PyErr_Occurred()) SWIG_fail;
17416 }
17417 {
17418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17419 }
17420 {
17421 if (temp2)
17422 delete arg2;
17423 }
17424 return resultobj;
17425 fail:
17426 {
17427 if (temp2)
17428 delete arg2;
17429 }
17430 return NULL;
17431 }
17432
17433
17434 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17435 PyObject *resultobj;
17436 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17437 wxString *arg2 = 0 ;
17438 wxConfigBase::EntryType result;
17439 bool temp2 = false ;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 char *kwnames[] = {
17443 (char *) "self",(char *) "name", NULL
17444 };
17445
17446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17448 if (SWIG_arg_fail(1)) SWIG_fail;
17449 {
17450 arg2 = wxString_in_helper(obj1);
17451 if (arg2 == NULL) SWIG_fail;
17452 temp2 = true;
17453 }
17454 {
17455 PyThreadState* __tstate = wxPyBeginAllowThreads();
17456 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17457
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 resultobj = SWIG_From_int((result));
17462 {
17463 if (temp2)
17464 delete arg2;
17465 }
17466 return resultobj;
17467 fail:
17468 {
17469 if (temp2)
17470 delete arg2;
17471 }
17472 return NULL;
17473 }
17474
17475
17476 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17477 PyObject *resultobj;
17478 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17479 wxString *arg2 = 0 ;
17480 wxString const &arg3_defvalue = wxPyEmptyString ;
17481 wxString *arg3 = (wxString *) &arg3_defvalue ;
17482 wxString result;
17483 bool temp2 = false ;
17484 bool temp3 = false ;
17485 PyObject * obj0 = 0 ;
17486 PyObject * obj1 = 0 ;
17487 PyObject * obj2 = 0 ;
17488 char *kwnames[] = {
17489 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17490 };
17491
17492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17494 if (SWIG_arg_fail(1)) SWIG_fail;
17495 {
17496 arg2 = wxString_in_helper(obj1);
17497 if (arg2 == NULL) SWIG_fail;
17498 temp2 = true;
17499 }
17500 if (obj2) {
17501 {
17502 arg3 = wxString_in_helper(obj2);
17503 if (arg3 == NULL) SWIG_fail;
17504 temp3 = true;
17505 }
17506 }
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17510
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 {
17515 #if wxUSE_UNICODE
17516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17517 #else
17518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17519 #endif
17520 }
17521 {
17522 if (temp2)
17523 delete arg2;
17524 }
17525 {
17526 if (temp3)
17527 delete arg3;
17528 }
17529 return resultobj;
17530 fail:
17531 {
17532 if (temp2)
17533 delete arg2;
17534 }
17535 {
17536 if (temp3)
17537 delete arg3;
17538 }
17539 return NULL;
17540 }
17541
17542
17543 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17544 PyObject *resultobj;
17545 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17546 wxString *arg2 = 0 ;
17547 long arg3 = (long) 0 ;
17548 long result;
17549 bool temp2 = false ;
17550 PyObject * obj0 = 0 ;
17551 PyObject * obj1 = 0 ;
17552 PyObject * obj2 = 0 ;
17553 char *kwnames[] = {
17554 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17555 };
17556
17557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17559 if (SWIG_arg_fail(1)) SWIG_fail;
17560 {
17561 arg2 = wxString_in_helper(obj1);
17562 if (arg2 == NULL) SWIG_fail;
17563 temp2 = true;
17564 }
17565 if (obj2) {
17566 {
17567 arg3 = (long)(SWIG_As_long(obj2));
17568 if (SWIG_arg_fail(3)) SWIG_fail;
17569 }
17570 }
17571 {
17572 PyThreadState* __tstate = wxPyBeginAllowThreads();
17573 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17574
17575 wxPyEndAllowThreads(__tstate);
17576 if (PyErr_Occurred()) SWIG_fail;
17577 }
17578 {
17579 resultobj = SWIG_From_long((long)(result));
17580 }
17581 {
17582 if (temp2)
17583 delete arg2;
17584 }
17585 return resultobj;
17586 fail:
17587 {
17588 if (temp2)
17589 delete arg2;
17590 }
17591 return NULL;
17592 }
17593
17594
17595 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17596 PyObject *resultobj;
17597 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17598 wxString *arg2 = 0 ;
17599 double arg3 = (double) 0.0 ;
17600 double result;
17601 bool temp2 = false ;
17602 PyObject * obj0 = 0 ;
17603 PyObject * obj1 = 0 ;
17604 PyObject * obj2 = 0 ;
17605 char *kwnames[] = {
17606 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17607 };
17608
17609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17611 if (SWIG_arg_fail(1)) SWIG_fail;
17612 {
17613 arg2 = wxString_in_helper(obj1);
17614 if (arg2 == NULL) SWIG_fail;
17615 temp2 = true;
17616 }
17617 if (obj2) {
17618 {
17619 arg3 = (double)(SWIG_As_double(obj2));
17620 if (SWIG_arg_fail(3)) SWIG_fail;
17621 }
17622 }
17623 {
17624 PyThreadState* __tstate = wxPyBeginAllowThreads();
17625 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17626
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 {
17631 resultobj = SWIG_From_double((double)(result));
17632 }
17633 {
17634 if (temp2)
17635 delete arg2;
17636 }
17637 return resultobj;
17638 fail:
17639 {
17640 if (temp2)
17641 delete arg2;
17642 }
17643 return NULL;
17644 }
17645
17646
17647 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17648 PyObject *resultobj;
17649 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17650 wxString *arg2 = 0 ;
17651 bool arg3 = (bool) false ;
17652 bool result;
17653 bool temp2 = false ;
17654 PyObject * obj0 = 0 ;
17655 PyObject * obj1 = 0 ;
17656 PyObject * obj2 = 0 ;
17657 char *kwnames[] = {
17658 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17659 };
17660
17661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17663 if (SWIG_arg_fail(1)) SWIG_fail;
17664 {
17665 arg2 = wxString_in_helper(obj1);
17666 if (arg2 == NULL) SWIG_fail;
17667 temp2 = true;
17668 }
17669 if (obj2) {
17670 {
17671 arg3 = (bool)(SWIG_As_bool(obj2));
17672 if (SWIG_arg_fail(3)) SWIG_fail;
17673 }
17674 }
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17678
17679 wxPyEndAllowThreads(__tstate);
17680 if (PyErr_Occurred()) SWIG_fail;
17681 }
17682 {
17683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17684 }
17685 {
17686 if (temp2)
17687 delete arg2;
17688 }
17689 return resultobj;
17690 fail:
17691 {
17692 if (temp2)
17693 delete arg2;
17694 }
17695 return NULL;
17696 }
17697
17698
17699 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17700 PyObject *resultobj;
17701 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17702 wxString *arg2 = 0 ;
17703 wxString *arg3 = 0 ;
17704 bool result;
17705 bool temp2 = false ;
17706 bool temp3 = false ;
17707 PyObject * obj0 = 0 ;
17708 PyObject * obj1 = 0 ;
17709 PyObject * obj2 = 0 ;
17710 char *kwnames[] = {
17711 (char *) "self",(char *) "key",(char *) "value", NULL
17712 };
17713
17714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17716 if (SWIG_arg_fail(1)) SWIG_fail;
17717 {
17718 arg2 = wxString_in_helper(obj1);
17719 if (arg2 == NULL) SWIG_fail;
17720 temp2 = true;
17721 }
17722 {
17723 arg3 = wxString_in_helper(obj2);
17724 if (arg3 == NULL) SWIG_fail;
17725 temp3 = true;
17726 }
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17736 }
17737 {
17738 if (temp2)
17739 delete arg2;
17740 }
17741 {
17742 if (temp3)
17743 delete arg3;
17744 }
17745 return resultobj;
17746 fail:
17747 {
17748 if (temp2)
17749 delete arg2;
17750 }
17751 {
17752 if (temp3)
17753 delete arg3;
17754 }
17755 return NULL;
17756 }
17757
17758
17759 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17760 PyObject *resultobj;
17761 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17762 wxString *arg2 = 0 ;
17763 long arg3 ;
17764 bool result;
17765 bool temp2 = false ;
17766 PyObject * obj0 = 0 ;
17767 PyObject * obj1 = 0 ;
17768 PyObject * obj2 = 0 ;
17769 char *kwnames[] = {
17770 (char *) "self",(char *) "key",(char *) "value", NULL
17771 };
17772
17773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17775 if (SWIG_arg_fail(1)) SWIG_fail;
17776 {
17777 arg2 = wxString_in_helper(obj1);
17778 if (arg2 == NULL) SWIG_fail;
17779 temp2 = true;
17780 }
17781 {
17782 arg3 = (long)(SWIG_As_long(obj2));
17783 if (SWIG_arg_fail(3)) SWIG_fail;
17784 }
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17788
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 {
17793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17794 }
17795 {
17796 if (temp2)
17797 delete arg2;
17798 }
17799 return resultobj;
17800 fail:
17801 {
17802 if (temp2)
17803 delete arg2;
17804 }
17805 return NULL;
17806 }
17807
17808
17809 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj;
17811 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17812 wxString *arg2 = 0 ;
17813 double arg3 ;
17814 bool result;
17815 bool temp2 = false ;
17816 PyObject * obj0 = 0 ;
17817 PyObject * obj1 = 0 ;
17818 PyObject * obj2 = 0 ;
17819 char *kwnames[] = {
17820 (char *) "self",(char *) "key",(char *) "value", NULL
17821 };
17822
17823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17825 if (SWIG_arg_fail(1)) SWIG_fail;
17826 {
17827 arg2 = wxString_in_helper(obj1);
17828 if (arg2 == NULL) SWIG_fail;
17829 temp2 = true;
17830 }
17831 {
17832 arg3 = (double)(SWIG_As_double(obj2));
17833 if (SWIG_arg_fail(3)) SWIG_fail;
17834 }
17835 {
17836 PyThreadState* __tstate = wxPyBeginAllowThreads();
17837 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17838
17839 wxPyEndAllowThreads(__tstate);
17840 if (PyErr_Occurred()) SWIG_fail;
17841 }
17842 {
17843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17844 }
17845 {
17846 if (temp2)
17847 delete arg2;
17848 }
17849 return resultobj;
17850 fail:
17851 {
17852 if (temp2)
17853 delete arg2;
17854 }
17855 return NULL;
17856 }
17857
17858
17859 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17860 PyObject *resultobj;
17861 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17862 wxString *arg2 = 0 ;
17863 bool arg3 ;
17864 bool result;
17865 bool temp2 = false ;
17866 PyObject * obj0 = 0 ;
17867 PyObject * obj1 = 0 ;
17868 PyObject * obj2 = 0 ;
17869 char *kwnames[] = {
17870 (char *) "self",(char *) "key",(char *) "value", NULL
17871 };
17872
17873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17875 if (SWIG_arg_fail(1)) SWIG_fail;
17876 {
17877 arg2 = wxString_in_helper(obj1);
17878 if (arg2 == NULL) SWIG_fail;
17879 temp2 = true;
17880 }
17881 {
17882 arg3 = (bool)(SWIG_As_bool(obj2));
17883 if (SWIG_arg_fail(3)) SWIG_fail;
17884 }
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17894 }
17895 {
17896 if (temp2)
17897 delete arg2;
17898 }
17899 return resultobj;
17900 fail:
17901 {
17902 if (temp2)
17903 delete arg2;
17904 }
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17912 bool arg2 = (bool) false ;
17913 bool result;
17914 PyObject * obj0 = 0 ;
17915 PyObject * obj1 = 0 ;
17916 char *kwnames[] = {
17917 (char *) "self",(char *) "currentOnly", NULL
17918 };
17919
17920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17922 if (SWIG_arg_fail(1)) SWIG_fail;
17923 if (obj1) {
17924 {
17925 arg2 = (bool)(SWIG_As_bool(obj1));
17926 if (SWIG_arg_fail(2)) SWIG_fail;
17927 }
17928 }
17929 {
17930 PyThreadState* __tstate = wxPyBeginAllowThreads();
17931 result = (bool)(arg1)->Flush(arg2);
17932
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 {
17937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17938 }
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj;
17947 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17948 wxString *arg2 = 0 ;
17949 wxString *arg3 = 0 ;
17950 bool result;
17951 bool temp2 = false ;
17952 bool temp3 = false ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 PyObject * obj2 = 0 ;
17956 char *kwnames[] = {
17957 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17958 };
17959
17960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17962 if (SWIG_arg_fail(1)) SWIG_fail;
17963 {
17964 arg2 = wxString_in_helper(obj1);
17965 if (arg2 == NULL) SWIG_fail;
17966 temp2 = true;
17967 }
17968 {
17969 arg3 = wxString_in_helper(obj2);
17970 if (arg3 == NULL) SWIG_fail;
17971 temp3 = true;
17972 }
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17976
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 {
17981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17982 }
17983 {
17984 if (temp2)
17985 delete arg2;
17986 }
17987 {
17988 if (temp3)
17989 delete arg3;
17990 }
17991 return resultobj;
17992 fail:
17993 {
17994 if (temp2)
17995 delete arg2;
17996 }
17997 {
17998 if (temp3)
17999 delete arg3;
18000 }
18001 return NULL;
18002 }
18003
18004
18005 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18006 PyObject *resultobj;
18007 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18008 wxString *arg2 = 0 ;
18009 wxString *arg3 = 0 ;
18010 bool result;
18011 bool temp2 = false ;
18012 bool temp3 = false ;
18013 PyObject * obj0 = 0 ;
18014 PyObject * obj1 = 0 ;
18015 PyObject * obj2 = 0 ;
18016 char *kwnames[] = {
18017 (char *) "self",(char *) "oldName",(char *) "newName", NULL
18018 };
18019
18020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
18021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18022 if (SWIG_arg_fail(1)) SWIG_fail;
18023 {
18024 arg2 = wxString_in_helper(obj1);
18025 if (arg2 == NULL) SWIG_fail;
18026 temp2 = true;
18027 }
18028 {
18029 arg3 = wxString_in_helper(obj2);
18030 if (arg3 == NULL) SWIG_fail;
18031 temp3 = true;
18032 }
18033 {
18034 PyThreadState* __tstate = wxPyBeginAllowThreads();
18035 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18036
18037 wxPyEndAllowThreads(__tstate);
18038 if (PyErr_Occurred()) SWIG_fail;
18039 }
18040 {
18041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18042 }
18043 {
18044 if (temp2)
18045 delete arg2;
18046 }
18047 {
18048 if (temp3)
18049 delete arg3;
18050 }
18051 return resultobj;
18052 fail:
18053 {
18054 if (temp2)
18055 delete arg2;
18056 }
18057 {
18058 if (temp3)
18059 delete arg3;
18060 }
18061 return NULL;
18062 }
18063
18064
18065 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18066 PyObject *resultobj;
18067 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18068 wxString *arg2 = 0 ;
18069 bool arg3 = (bool) true ;
18070 bool result;
18071 bool temp2 = false ;
18072 PyObject * obj0 = 0 ;
18073 PyObject * obj1 = 0 ;
18074 PyObject * obj2 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18081 if (SWIG_arg_fail(1)) SWIG_fail;
18082 {
18083 arg2 = wxString_in_helper(obj1);
18084 if (arg2 == NULL) SWIG_fail;
18085 temp2 = true;
18086 }
18087 if (obj2) {
18088 {
18089 arg3 = (bool)(SWIG_As_bool(obj2));
18090 if (SWIG_arg_fail(3)) SWIG_fail;
18091 }
18092 }
18093 {
18094 PyThreadState* __tstate = wxPyBeginAllowThreads();
18095 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18096
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18102 }
18103 {
18104 if (temp2)
18105 delete arg2;
18106 }
18107 return resultobj;
18108 fail:
18109 {
18110 if (temp2)
18111 delete arg2;
18112 }
18113 return NULL;
18114 }
18115
18116
18117 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj;
18119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18120 wxString *arg2 = 0 ;
18121 bool result;
18122 bool temp2 = false ;
18123 PyObject * obj0 = 0 ;
18124 PyObject * obj1 = 0 ;
18125 char *kwnames[] = {
18126 (char *) "self",(char *) "key", NULL
18127 };
18128
18129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18131 if (SWIG_arg_fail(1)) SWIG_fail;
18132 {
18133 arg2 = wxString_in_helper(obj1);
18134 if (arg2 == NULL) SWIG_fail;
18135 temp2 = true;
18136 }
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18140
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 {
18145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18146 }
18147 {
18148 if (temp2)
18149 delete arg2;
18150 }
18151 return resultobj;
18152 fail:
18153 {
18154 if (temp2)
18155 delete arg2;
18156 }
18157 return NULL;
18158 }
18159
18160
18161 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18162 PyObject *resultobj;
18163 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18164 bool result;
18165 PyObject * obj0 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 PyThreadState* __tstate = wxPyBeginAllowThreads();
18175 result = (bool)(arg1)->DeleteAll();
18176
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 {
18181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18182 }
18183 return resultobj;
18184 fail:
18185 return NULL;
18186 }
18187
18188
18189 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18190 PyObject *resultobj;
18191 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18192 bool arg2 = (bool) true ;
18193 PyObject * obj0 = 0 ;
18194 PyObject * obj1 = 0 ;
18195 char *kwnames[] = {
18196 (char *) "self",(char *) "doIt", NULL
18197 };
18198
18199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18201 if (SWIG_arg_fail(1)) SWIG_fail;
18202 if (obj1) {
18203 {
18204 arg2 = (bool)(SWIG_As_bool(obj1));
18205 if (SWIG_arg_fail(2)) SWIG_fail;
18206 }
18207 }
18208 {
18209 PyThreadState* __tstate = wxPyBeginAllowThreads();
18210 (arg1)->SetExpandEnvVars(arg2);
18211
18212 wxPyEndAllowThreads(__tstate);
18213 if (PyErr_Occurred()) SWIG_fail;
18214 }
18215 Py_INCREF(Py_None); resultobj = Py_None;
18216 return resultobj;
18217 fail:
18218 return NULL;
18219 }
18220
18221
18222 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18223 PyObject *resultobj;
18224 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18225 bool result;
18226 PyObject * obj0 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "self", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(1)) SWIG_fail;
18234 {
18235 PyThreadState* __tstate = wxPyBeginAllowThreads();
18236 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18237
18238 wxPyEndAllowThreads(__tstate);
18239 if (PyErr_Occurred()) SWIG_fail;
18240 }
18241 {
18242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18243 }
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18251 PyObject *resultobj;
18252 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18253 bool arg2 = (bool) true ;
18254 PyObject * obj0 = 0 ;
18255 PyObject * obj1 = 0 ;
18256 char *kwnames[] = {
18257 (char *) "self",(char *) "doIt", NULL
18258 };
18259
18260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18262 if (SWIG_arg_fail(1)) SWIG_fail;
18263 if (obj1) {
18264 {
18265 arg2 = (bool)(SWIG_As_bool(obj1));
18266 if (SWIG_arg_fail(2)) SWIG_fail;
18267 }
18268 }
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 (arg1)->SetRecordDefaults(arg2);
18272
18273 wxPyEndAllowThreads(__tstate);
18274 if (PyErr_Occurred()) SWIG_fail;
18275 }
18276 Py_INCREF(Py_None); resultobj = Py_None;
18277 return resultobj;
18278 fail:
18279 return NULL;
18280 }
18281
18282
18283 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18284 PyObject *resultobj;
18285 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18286 bool result;
18287 PyObject * obj0 = 0 ;
18288 char *kwnames[] = {
18289 (char *) "self", NULL
18290 };
18291
18292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18294 if (SWIG_arg_fail(1)) SWIG_fail;
18295 {
18296 PyThreadState* __tstate = wxPyBeginAllowThreads();
18297 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18298
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 {
18303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18304 }
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj;
18313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18314 wxString *arg2 = 0 ;
18315 wxString result;
18316 bool temp2 = false ;
18317 PyObject * obj0 = 0 ;
18318 PyObject * obj1 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self",(char *) "str", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 {
18327 arg2 = wxString_in_helper(obj1);
18328 if (arg2 == NULL) SWIG_fail;
18329 temp2 = true;
18330 }
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18334
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 {
18339 #if wxUSE_UNICODE
18340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18341 #else
18342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18343 #endif
18344 }
18345 {
18346 if (temp2)
18347 delete arg2;
18348 }
18349 return resultobj;
18350 fail:
18351 {
18352 if (temp2)
18353 delete arg2;
18354 }
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18362 wxString result;
18363 PyObject * obj0 = 0 ;
18364 char *kwnames[] = {
18365 (char *) "self", NULL
18366 };
18367
18368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18370 if (SWIG_arg_fail(1)) SWIG_fail;
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 result = ((wxConfigBase const *)arg1)->GetAppName();
18374
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 {
18379 #if wxUSE_UNICODE
18380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18381 #else
18382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18383 #endif
18384 }
18385 return resultobj;
18386 fail:
18387 return NULL;
18388 }
18389
18390
18391 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18392 PyObject *resultobj;
18393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18394 wxString result;
18395 PyObject * obj0 = 0 ;
18396 char *kwnames[] = {
18397 (char *) "self", NULL
18398 };
18399
18400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18402 if (SWIG_arg_fail(1)) SWIG_fail;
18403 {
18404 PyThreadState* __tstate = wxPyBeginAllowThreads();
18405 result = ((wxConfigBase const *)arg1)->GetVendorName();
18406
18407 wxPyEndAllowThreads(__tstate);
18408 if (PyErr_Occurred()) SWIG_fail;
18409 }
18410 {
18411 #if wxUSE_UNICODE
18412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18413 #else
18414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18415 #endif
18416 }
18417 return resultobj;
18418 fail:
18419 return NULL;
18420 }
18421
18422
18423 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18424 PyObject *resultobj;
18425 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18426 wxString *arg2 = 0 ;
18427 bool temp2 = false ;
18428 PyObject * obj0 = 0 ;
18429 PyObject * obj1 = 0 ;
18430 char *kwnames[] = {
18431 (char *) "self",(char *) "appName", NULL
18432 };
18433
18434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18436 if (SWIG_arg_fail(1)) SWIG_fail;
18437 {
18438 arg2 = wxString_in_helper(obj1);
18439 if (arg2 == NULL) SWIG_fail;
18440 temp2 = true;
18441 }
18442 {
18443 PyThreadState* __tstate = wxPyBeginAllowThreads();
18444 (arg1)->SetAppName((wxString const &)*arg2);
18445
18446 wxPyEndAllowThreads(__tstate);
18447 if (PyErr_Occurred()) SWIG_fail;
18448 }
18449 Py_INCREF(Py_None); resultobj = Py_None;
18450 {
18451 if (temp2)
18452 delete arg2;
18453 }
18454 return resultobj;
18455 fail:
18456 {
18457 if (temp2)
18458 delete arg2;
18459 }
18460 return NULL;
18461 }
18462
18463
18464 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18465 PyObject *resultobj;
18466 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18467 wxString *arg2 = 0 ;
18468 bool temp2 = false ;
18469 PyObject * obj0 = 0 ;
18470 PyObject * obj1 = 0 ;
18471 char *kwnames[] = {
18472 (char *) "self",(char *) "vendorName", NULL
18473 };
18474
18475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18477 if (SWIG_arg_fail(1)) SWIG_fail;
18478 {
18479 arg2 = wxString_in_helper(obj1);
18480 if (arg2 == NULL) SWIG_fail;
18481 temp2 = true;
18482 }
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 (arg1)->SetVendorName((wxString const &)*arg2);
18486
18487 wxPyEndAllowThreads(__tstate);
18488 if (PyErr_Occurred()) SWIG_fail;
18489 }
18490 Py_INCREF(Py_None); resultobj = Py_None;
18491 {
18492 if (temp2)
18493 delete arg2;
18494 }
18495 return resultobj;
18496 fail:
18497 {
18498 if (temp2)
18499 delete arg2;
18500 }
18501 return NULL;
18502 }
18503
18504
18505 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18506 PyObject *resultobj;
18507 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18508 long arg2 ;
18509 PyObject * obj0 = 0 ;
18510 PyObject * obj1 = 0 ;
18511 char *kwnames[] = {
18512 (char *) "self",(char *) "style", NULL
18513 };
18514
18515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18517 if (SWIG_arg_fail(1)) SWIG_fail;
18518 {
18519 arg2 = (long)(SWIG_As_long(obj1));
18520 if (SWIG_arg_fail(2)) SWIG_fail;
18521 }
18522 {
18523 PyThreadState* __tstate = wxPyBeginAllowThreads();
18524 (arg1)->SetStyle(arg2);
18525
18526 wxPyEndAllowThreads(__tstate);
18527 if (PyErr_Occurred()) SWIG_fail;
18528 }
18529 Py_INCREF(Py_None); resultobj = Py_None;
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18537 PyObject *resultobj;
18538 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18539 long result;
18540 PyObject * obj0 = 0 ;
18541 char *kwnames[] = {
18542 (char *) "self", NULL
18543 };
18544
18545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18547 if (SWIG_arg_fail(1)) SWIG_fail;
18548 {
18549 PyThreadState* __tstate = wxPyBeginAllowThreads();
18550 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18551
18552 wxPyEndAllowThreads(__tstate);
18553 if (PyErr_Occurred()) SWIG_fail;
18554 }
18555 {
18556 resultobj = SWIG_From_long((long)(result));
18557 }
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18565 PyObject *obj;
18566 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18567 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18568 Py_INCREF(obj);
18569 return Py_BuildValue((char *)"");
18570 }
18571 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18572 PyObject *resultobj;
18573 wxString const &arg1_defvalue = wxPyEmptyString ;
18574 wxString *arg1 = (wxString *) &arg1_defvalue ;
18575 wxString const &arg2_defvalue = wxPyEmptyString ;
18576 wxString *arg2 = (wxString *) &arg2_defvalue ;
18577 wxString const &arg3_defvalue = wxPyEmptyString ;
18578 wxString *arg3 = (wxString *) &arg3_defvalue ;
18579 wxString const &arg4_defvalue = wxPyEmptyString ;
18580 wxString *arg4 = (wxString *) &arg4_defvalue ;
18581 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18582 wxConfig *result;
18583 bool temp1 = false ;
18584 bool temp2 = false ;
18585 bool temp3 = false ;
18586 bool temp4 = false ;
18587 PyObject * obj0 = 0 ;
18588 PyObject * obj1 = 0 ;
18589 PyObject * obj2 = 0 ;
18590 PyObject * obj3 = 0 ;
18591 PyObject * obj4 = 0 ;
18592 char *kwnames[] = {
18593 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18594 };
18595
18596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18597 if (obj0) {
18598 {
18599 arg1 = wxString_in_helper(obj0);
18600 if (arg1 == NULL) SWIG_fail;
18601 temp1 = true;
18602 }
18603 }
18604 if (obj1) {
18605 {
18606 arg2 = wxString_in_helper(obj1);
18607 if (arg2 == NULL) SWIG_fail;
18608 temp2 = true;
18609 }
18610 }
18611 if (obj2) {
18612 {
18613 arg3 = wxString_in_helper(obj2);
18614 if (arg3 == NULL) SWIG_fail;
18615 temp3 = true;
18616 }
18617 }
18618 if (obj3) {
18619 {
18620 arg4 = wxString_in_helper(obj3);
18621 if (arg4 == NULL) SWIG_fail;
18622 temp4 = true;
18623 }
18624 }
18625 if (obj4) {
18626 {
18627 arg5 = (long)(SWIG_As_long(obj4));
18628 if (SWIG_arg_fail(5)) SWIG_fail;
18629 }
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18634
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18639 {
18640 if (temp1)
18641 delete arg1;
18642 }
18643 {
18644 if (temp2)
18645 delete arg2;
18646 }
18647 {
18648 if (temp3)
18649 delete arg3;
18650 }
18651 {
18652 if (temp4)
18653 delete arg4;
18654 }
18655 return resultobj;
18656 fail:
18657 {
18658 if (temp1)
18659 delete arg1;
18660 }
18661 {
18662 if (temp2)
18663 delete arg2;
18664 }
18665 {
18666 if (temp3)
18667 delete arg3;
18668 }
18669 {
18670 if (temp4)
18671 delete arg4;
18672 }
18673 return NULL;
18674 }
18675
18676
18677 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18678 PyObject *resultobj;
18679 wxConfig *arg1 = (wxConfig *) 0 ;
18680 PyObject * obj0 = 0 ;
18681 char *kwnames[] = {
18682 (char *) "self", NULL
18683 };
18684
18685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18687 if (SWIG_arg_fail(1)) SWIG_fail;
18688 {
18689 PyThreadState* __tstate = wxPyBeginAllowThreads();
18690 delete arg1;
18691
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 Py_INCREF(Py_None); resultobj = Py_None;
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18703 PyObject *obj;
18704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18705 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18706 Py_INCREF(obj);
18707 return Py_BuildValue((char *)"");
18708 }
18709 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxString const &arg1_defvalue = wxPyEmptyString ;
18712 wxString *arg1 = (wxString *) &arg1_defvalue ;
18713 wxString const &arg2_defvalue = wxPyEmptyString ;
18714 wxString *arg2 = (wxString *) &arg2_defvalue ;
18715 wxString const &arg3_defvalue = wxPyEmptyString ;
18716 wxString *arg3 = (wxString *) &arg3_defvalue ;
18717 wxString const &arg4_defvalue = wxPyEmptyString ;
18718 wxString *arg4 = (wxString *) &arg4_defvalue ;
18719 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18720 wxFileConfig *result;
18721 bool temp1 = false ;
18722 bool temp2 = false ;
18723 bool temp3 = false ;
18724 bool temp4 = false ;
18725 PyObject * obj0 = 0 ;
18726 PyObject * obj1 = 0 ;
18727 PyObject * obj2 = 0 ;
18728 PyObject * obj3 = 0 ;
18729 PyObject * obj4 = 0 ;
18730 char *kwnames[] = {
18731 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18732 };
18733
18734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18735 if (obj0) {
18736 {
18737 arg1 = wxString_in_helper(obj0);
18738 if (arg1 == NULL) SWIG_fail;
18739 temp1 = true;
18740 }
18741 }
18742 if (obj1) {
18743 {
18744 arg2 = wxString_in_helper(obj1);
18745 if (arg2 == NULL) SWIG_fail;
18746 temp2 = true;
18747 }
18748 }
18749 if (obj2) {
18750 {
18751 arg3 = wxString_in_helper(obj2);
18752 if (arg3 == NULL) SWIG_fail;
18753 temp3 = true;
18754 }
18755 }
18756 if (obj3) {
18757 {
18758 arg4 = wxString_in_helper(obj3);
18759 if (arg4 == NULL) SWIG_fail;
18760 temp4 = true;
18761 }
18762 }
18763 if (obj4) {
18764 {
18765 arg5 = (long)(SWIG_As_long(obj4));
18766 if (SWIG_arg_fail(5)) SWIG_fail;
18767 }
18768 }
18769 {
18770 PyThreadState* __tstate = wxPyBeginAllowThreads();
18771 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18772
18773 wxPyEndAllowThreads(__tstate);
18774 if (PyErr_Occurred()) SWIG_fail;
18775 }
18776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18777 {
18778 if (temp1)
18779 delete arg1;
18780 }
18781 {
18782 if (temp2)
18783 delete arg2;
18784 }
18785 {
18786 if (temp3)
18787 delete arg3;
18788 }
18789 {
18790 if (temp4)
18791 delete arg4;
18792 }
18793 return resultobj;
18794 fail:
18795 {
18796 if (temp1)
18797 delete arg1;
18798 }
18799 {
18800 if (temp2)
18801 delete arg2;
18802 }
18803 {
18804 if (temp3)
18805 delete arg3;
18806 }
18807 {
18808 if (temp4)
18809 delete arg4;
18810 }
18811 return NULL;
18812 }
18813
18814
18815 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj;
18817 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18818 PyObject * obj0 = 0 ;
18819 char *kwnames[] = {
18820 (char *) "self", NULL
18821 };
18822
18823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18825 if (SWIG_arg_fail(1)) SWIG_fail;
18826 {
18827 PyThreadState* __tstate = wxPyBeginAllowThreads();
18828 delete arg1;
18829
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 Py_INCREF(Py_None); resultobj = Py_None;
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18841 PyObject *obj;
18842 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18843 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18844 Py_INCREF(obj);
18845 return Py_BuildValue((char *)"");
18846 }
18847 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18848 PyObject *resultobj;
18849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18850 wxString *arg2 = 0 ;
18851 wxConfigPathChanger *result;
18852 bool temp2 = false ;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char *kwnames[] = {
18856 (char *) "config",(char *) "entry", NULL
18857 };
18858
18859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18861 if (SWIG_arg_fail(1)) SWIG_fail;
18862 {
18863 arg2 = wxString_in_helper(obj1);
18864 if (arg2 == NULL) SWIG_fail;
18865 temp2 = true;
18866 }
18867 {
18868 PyThreadState* __tstate = wxPyBeginAllowThreads();
18869 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18870
18871 wxPyEndAllowThreads(__tstate);
18872 if (PyErr_Occurred()) SWIG_fail;
18873 }
18874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18875 {
18876 if (temp2)
18877 delete arg2;
18878 }
18879 return resultobj;
18880 fail:
18881 {
18882 if (temp2)
18883 delete arg2;
18884 }
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18892 PyObject * obj0 = 0 ;
18893 char *kwnames[] = {
18894 (char *) "self", NULL
18895 };
18896
18897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18899 if (SWIG_arg_fail(1)) SWIG_fail;
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 delete arg1;
18903
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 Py_INCREF(Py_None); resultobj = Py_None;
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj;
18916 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18917 wxString *result;
18918 PyObject * obj0 = 0 ;
18919 char *kwnames[] = {
18920 (char *) "self", NULL
18921 };
18922
18923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18925 if (SWIG_arg_fail(1)) SWIG_fail;
18926 {
18927 PyThreadState* __tstate = wxPyBeginAllowThreads();
18928 {
18929 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18930 result = (wxString *) &_result_ref;
18931 }
18932
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 {
18937 #if wxUSE_UNICODE
18938 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18939 #else
18940 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18941 #endif
18942 }
18943 return resultobj;
18944 fail:
18945 return NULL;
18946 }
18947
18948
18949 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18950 PyObject *obj;
18951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18952 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18953 Py_INCREF(obj);
18954 return Py_BuildValue((char *)"");
18955 }
18956 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj;
18958 wxString *arg1 = 0 ;
18959 wxString result;
18960 bool temp1 = false ;
18961 PyObject * obj0 = 0 ;
18962 char *kwnames[] = {
18963 (char *) "sz", NULL
18964 };
18965
18966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18967 {
18968 arg1 = wxString_in_helper(obj0);
18969 if (arg1 == NULL) SWIG_fail;
18970 temp1 = true;
18971 }
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 result = wxExpandEnvVars((wxString const &)*arg1);
18975
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 {
18980 #if wxUSE_UNICODE
18981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18982 #else
18983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18984 #endif
18985 }
18986 {
18987 if (temp1)
18988 delete arg1;
18989 }
18990 return resultobj;
18991 fail:
18992 {
18993 if (temp1)
18994 delete arg1;
18995 }
18996 return NULL;
18997 }
18998
18999
19000 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
19001 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
19002 return 1;
19003 }
19004
19005
19006 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
19007 PyObject *pyobj;
19008
19009 {
19010 #if wxUSE_UNICODE
19011 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19012 #else
19013 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
19014 #endif
19015 }
19016 return pyobj;
19017 }
19018
19019
19020 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
19021 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
19022 return 1;
19023 }
19024
19025
19026 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
19027 PyObject *pyobj;
19028
19029 {
19030 #if wxUSE_UNICODE
19031 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19032 #else
19033 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
19034 #endif
19035 }
19036 return pyobj;
19037 }
19038
19039
19040 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19041 PyObject *resultobj;
19042 wxDateTime::Country arg1 ;
19043 PyObject * obj0 = 0 ;
19044 char *kwnames[] = {
19045 (char *) "country", NULL
19046 };
19047
19048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19049 {
19050 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19051 if (SWIG_arg_fail(1)) SWIG_fail;
19052 }
19053 {
19054 PyThreadState* __tstate = wxPyBeginAllowThreads();
19055 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19056
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 Py_INCREF(Py_None); resultobj = Py_None;
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19068 PyObject *resultobj;
19069 wxDateTime::Country result;
19070 char *kwnames[] = {
19071 NULL
19072 };
19073
19074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = (wxDateTime::Country)wxDateTime::GetCountry();
19078
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_From_int((result));
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19090 PyObject *resultobj;
19091 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19092 bool result;
19093 PyObject * obj0 = 0 ;
19094 char *kwnames[] = {
19095 (char *) "country", NULL
19096 };
19097
19098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19099 if (obj0) {
19100 {
19101 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19102 if (SWIG_arg_fail(1)) SWIG_fail;
19103 }
19104 }
19105 {
19106 PyThreadState* __tstate = wxPyBeginAllowThreads();
19107 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19108
19109 wxPyEndAllowThreads(__tstate);
19110 if (PyErr_Occurred()) SWIG_fail;
19111 }
19112 {
19113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19114 }
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj;
19123 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19124 int result;
19125 PyObject * obj0 = 0 ;
19126 char *kwnames[] = {
19127 (char *) "cal", NULL
19128 };
19129
19130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19131 if (obj0) {
19132 {
19133 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19134 if (SWIG_arg_fail(1)) SWIG_fail;
19135 }
19136 }
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19140
19141 wxPyEndAllowThreads(__tstate);
19142 if (PyErr_Occurred()) SWIG_fail;
19143 }
19144 {
19145 resultobj = SWIG_From_int((int)(result));
19146 }
19147 return resultobj;
19148 fail:
19149 return NULL;
19150 }
19151
19152
19153 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19154 PyObject *resultobj;
19155 int arg1 ;
19156 int result;
19157 PyObject * obj0 = 0 ;
19158 char *kwnames[] = {
19159 (char *) "year", NULL
19160 };
19161
19162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19163 {
19164 arg1 = (int)(SWIG_As_int(obj0));
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 }
19167 {
19168 PyThreadState* __tstate = wxPyBeginAllowThreads();
19169 result = (int)wxDateTime::ConvertYearToBC(arg1);
19170
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 {
19175 resultobj = SWIG_From_int((int)(result));
19176 }
19177 return resultobj;
19178 fail:
19179 return NULL;
19180 }
19181
19182
19183 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19184 PyObject *resultobj;
19185 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19186 wxDateTime::Month result;
19187 PyObject * obj0 = 0 ;
19188 char *kwnames[] = {
19189 (char *) "cal", NULL
19190 };
19191
19192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19193 if (obj0) {
19194 {
19195 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19196 if (SWIG_arg_fail(1)) SWIG_fail;
19197 }
19198 }
19199 {
19200 PyThreadState* __tstate = wxPyBeginAllowThreads();
19201 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19202
19203 wxPyEndAllowThreads(__tstate);
19204 if (PyErr_Occurred()) SWIG_fail;
19205 }
19206 resultobj = SWIG_From_int((result));
19207 return resultobj;
19208 fail:
19209 return NULL;
19210 }
19211
19212
19213 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19214 PyObject *resultobj;
19215 int arg1 = (int) wxDateTime::Inv_Year ;
19216 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19217 bool result;
19218 PyObject * obj0 = 0 ;
19219 PyObject * obj1 = 0 ;
19220 char *kwnames[] = {
19221 (char *) "year",(char *) "cal", NULL
19222 };
19223
19224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19225 if (obj0) {
19226 {
19227 arg1 = (int)(SWIG_As_int(obj0));
19228 if (SWIG_arg_fail(1)) SWIG_fail;
19229 }
19230 }
19231 if (obj1) {
19232 {
19233 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19234 if (SWIG_arg_fail(2)) SWIG_fail;
19235 }
19236 }
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19240
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 {
19245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19246 }
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj;
19255 int arg1 = (int) wxDateTime::Inv_Year ;
19256 int result;
19257 PyObject * obj0 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "year", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19263 if (obj0) {
19264 {
19265 arg1 = (int)(SWIG_As_int(obj0));
19266 if (SWIG_arg_fail(1)) SWIG_fail;
19267 }
19268 }
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (int)wxDateTime::GetCentury(arg1);
19272
19273 wxPyEndAllowThreads(__tstate);
19274 if (PyErr_Occurred()) SWIG_fail;
19275 }
19276 {
19277 resultobj = SWIG_From_int((int)(result));
19278 }
19279 return resultobj;
19280 fail:
19281 return NULL;
19282 }
19283
19284
19285 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19286 PyObject *resultobj;
19287 int arg1 ;
19288 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19289 int result;
19290 PyObject * obj0 = 0 ;
19291 PyObject * obj1 = 0 ;
19292 char *kwnames[] = {
19293 (char *) "year",(char *) "cal", NULL
19294 };
19295
19296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19297 {
19298 arg1 = (int)(SWIG_As_int(obj0));
19299 if (SWIG_arg_fail(1)) SWIG_fail;
19300 }
19301 if (obj1) {
19302 {
19303 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19304 if (SWIG_arg_fail(2)) SWIG_fail;
19305 }
19306 }
19307 {
19308 PyThreadState* __tstate = wxPyBeginAllowThreads();
19309 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19310
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 {
19315 resultobj = SWIG_From_int((int)(result));
19316 }
19317 return resultobj;
19318 fail:
19319 return NULL;
19320 }
19321
19322
19323 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19324 PyObject *resultobj;
19325 wxDateTime::Month arg1 ;
19326 int arg2 = (int) wxDateTime::Inv_Year ;
19327 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19328 int result;
19329 PyObject * obj0 = 0 ;
19330 PyObject * obj1 = 0 ;
19331 PyObject * obj2 = 0 ;
19332 char *kwnames[] = {
19333 (char *) "month",(char *) "year",(char *) "cal", NULL
19334 };
19335
19336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19337 {
19338 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19339 if (SWIG_arg_fail(1)) SWIG_fail;
19340 }
19341 if (obj1) {
19342 {
19343 arg2 = (int)(SWIG_As_int(obj1));
19344 if (SWIG_arg_fail(2)) SWIG_fail;
19345 }
19346 }
19347 if (obj2) {
19348 {
19349 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19350 if (SWIG_arg_fail(3)) SWIG_fail;
19351 }
19352 }
19353 {
19354 PyThreadState* __tstate = wxPyBeginAllowThreads();
19355 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19356
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 {
19361 resultobj = SWIG_From_int((int)(result));
19362 }
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj;
19371 wxDateTime::Month arg1 ;
19372 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19373 wxString result;
19374 PyObject * obj0 = 0 ;
19375 PyObject * obj1 = 0 ;
19376 char *kwnames[] = {
19377 (char *) "month",(char *) "flags", NULL
19378 };
19379
19380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19381 {
19382 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19383 if (SWIG_arg_fail(1)) SWIG_fail;
19384 }
19385 if (obj1) {
19386 {
19387 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19388 if (SWIG_arg_fail(2)) SWIG_fail;
19389 }
19390 }
19391 {
19392 PyThreadState* __tstate = wxPyBeginAllowThreads();
19393 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19394
19395 wxPyEndAllowThreads(__tstate);
19396 if (PyErr_Occurred()) SWIG_fail;
19397 }
19398 {
19399 #if wxUSE_UNICODE
19400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19401 #else
19402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19403 #endif
19404 }
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19412 PyObject *resultobj;
19413 wxDateTime::WeekDay arg1 ;
19414 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19415 wxString result;
19416 PyObject * obj0 = 0 ;
19417 PyObject * obj1 = 0 ;
19418 char *kwnames[] = {
19419 (char *) "weekday",(char *) "flags", NULL
19420 };
19421
19422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19423 {
19424 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19425 if (SWIG_arg_fail(1)) SWIG_fail;
19426 }
19427 if (obj1) {
19428 {
19429 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19430 if (SWIG_arg_fail(2)) SWIG_fail;
19431 }
19432 }
19433 {
19434 PyThreadState* __tstate = wxPyBeginAllowThreads();
19435 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19436
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 {
19441 #if wxUSE_UNICODE
19442 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19443 #else
19444 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19445 #endif
19446 }
19447 return resultobj;
19448 fail:
19449 return NULL;
19450 }
19451
19452
19453 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19454 PyObject *resultobj;
19455 PyObject *result;
19456 char *kwnames[] = {
19457 NULL
19458 };
19459
19460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (PyObject *)DateTime_GetAmPmStrings();
19464
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = result;
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19476 PyObject *resultobj;
19477 int arg1 = (int) wxDateTime::Inv_Year ;
19478 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19479 bool result;
19480 PyObject * obj0 = 0 ;
19481 PyObject * obj1 = 0 ;
19482 char *kwnames[] = {
19483 (char *) "year",(char *) "country", NULL
19484 };
19485
19486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19487 if (obj0) {
19488 {
19489 arg1 = (int)(SWIG_As_int(obj0));
19490 if (SWIG_arg_fail(1)) SWIG_fail;
19491 }
19492 }
19493 if (obj1) {
19494 {
19495 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19496 if (SWIG_arg_fail(2)) SWIG_fail;
19497 }
19498 }
19499 {
19500 PyThreadState* __tstate = wxPyBeginAllowThreads();
19501 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19502
19503 wxPyEndAllowThreads(__tstate);
19504 if (PyErr_Occurred()) SWIG_fail;
19505 }
19506 {
19507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19508 }
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj;
19517 int arg1 = (int) wxDateTime::Inv_Year ;
19518 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19519 wxDateTime result;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char *kwnames[] = {
19523 (char *) "year",(char *) "country", NULL
19524 };
19525
19526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19527 if (obj0) {
19528 {
19529 arg1 = (int)(SWIG_As_int(obj0));
19530 if (SWIG_arg_fail(1)) SWIG_fail;
19531 }
19532 }
19533 if (obj1) {
19534 {
19535 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19536 if (SWIG_arg_fail(2)) SWIG_fail;
19537 }
19538 }
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19542
19543 wxPyEndAllowThreads(__tstate);
19544 if (PyErr_Occurred()) SWIG_fail;
19545 }
19546 {
19547 wxDateTime * resultptr;
19548 resultptr = new wxDateTime((wxDateTime &)(result));
19549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19550 }
19551 return resultobj;
19552 fail:
19553 return NULL;
19554 }
19555
19556
19557 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19558 PyObject *resultobj;
19559 int arg1 = (int) wxDateTime::Inv_Year ;
19560 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19561 wxDateTime result;
19562 PyObject * obj0 = 0 ;
19563 PyObject * obj1 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "year",(char *) "country", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19569 if (obj0) {
19570 {
19571 arg1 = (int)(SWIG_As_int(obj0));
19572 if (SWIG_arg_fail(1)) SWIG_fail;
19573 }
19574 }
19575 if (obj1) {
19576 {
19577 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19578 if (SWIG_arg_fail(2)) SWIG_fail;
19579 }
19580 }
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19584
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 {
19589 wxDateTime * resultptr;
19590 resultptr = new wxDateTime((wxDateTime &)(result));
19591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxDateTime result;
19602 char *kwnames[] = {
19603 NULL
19604 };
19605
19606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19607 {
19608 PyThreadState* __tstate = wxPyBeginAllowThreads();
19609 result = wxDateTime::Now();
19610
19611 wxPyEndAllowThreads(__tstate);
19612 if (PyErr_Occurred()) SWIG_fail;
19613 }
19614 {
19615 wxDateTime * resultptr;
19616 resultptr = new wxDateTime((wxDateTime &)(result));
19617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19618 }
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj;
19627 wxDateTime result;
19628 char *kwnames[] = {
19629 NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19633 {
19634 PyThreadState* __tstate = wxPyBeginAllowThreads();
19635 result = wxDateTime::UNow();
19636
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 {
19641 wxDateTime * resultptr;
19642 resultptr = new wxDateTime((wxDateTime &)(result));
19643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxDateTime result;
19654 char *kwnames[] = {
19655 NULL
19656 };
19657
19658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = wxDateTime::Today();
19662
19663 wxPyEndAllowThreads(__tstate);
19664 if (PyErr_Occurred()) SWIG_fail;
19665 }
19666 {
19667 wxDateTime * resultptr;
19668 resultptr = new wxDateTime((wxDateTime &)(result));
19669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19670 }
19671 return resultobj;
19672 fail:
19673 return NULL;
19674 }
19675
19676
19677 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19678 PyObject *resultobj;
19679 wxDateTime *result;
19680 char *kwnames[] = {
19681 NULL
19682 };
19683
19684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 result = (wxDateTime *)new wxDateTime();
19688
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19700 PyObject *resultobj;
19701 time_t arg1 ;
19702 wxDateTime *result;
19703 PyObject * obj0 = 0 ;
19704 char *kwnames[] = {
19705 (char *) "timet", NULL
19706 };
19707
19708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19709 {
19710 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19711 if (SWIG_arg_fail(1)) SWIG_fail;
19712 }
19713 {
19714 PyThreadState* __tstate = wxPyBeginAllowThreads();
19715 result = (wxDateTime *)new wxDateTime(arg1);
19716
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19728 PyObject *resultobj;
19729 double arg1 ;
19730 wxDateTime *result;
19731 PyObject * obj0 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "jdn", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19737 {
19738 arg1 = (double)(SWIG_As_double(obj0));
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 }
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (wxDateTime *)new wxDateTime(arg1);
19744
19745 wxPyEndAllowThreads(__tstate);
19746 if (PyErr_Occurred()) SWIG_fail;
19747 }
19748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19749 return resultobj;
19750 fail:
19751 return NULL;
19752 }
19753
19754
19755 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19756 PyObject *resultobj;
19757 int arg1 ;
19758 int arg2 = (int) 0 ;
19759 int arg3 = (int) 0 ;
19760 int arg4 = (int) 0 ;
19761 wxDateTime *result;
19762 PyObject * obj0 = 0 ;
19763 PyObject * obj1 = 0 ;
19764 PyObject * obj2 = 0 ;
19765 PyObject * obj3 = 0 ;
19766 char *kwnames[] = {
19767 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19768 };
19769
19770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19771 {
19772 arg1 = (int)(SWIG_As_int(obj0));
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 }
19775 if (obj1) {
19776 {
19777 arg2 = (int)(SWIG_As_int(obj1));
19778 if (SWIG_arg_fail(2)) SWIG_fail;
19779 }
19780 }
19781 if (obj2) {
19782 {
19783 arg3 = (int)(SWIG_As_int(obj2));
19784 if (SWIG_arg_fail(3)) SWIG_fail;
19785 }
19786 }
19787 if (obj3) {
19788 {
19789 arg4 = (int)(SWIG_As_int(obj3));
19790 if (SWIG_arg_fail(4)) SWIG_fail;
19791 }
19792 }
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19796
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19801 return resultobj;
19802 fail:
19803 return NULL;
19804 }
19805
19806
19807 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19808 PyObject *resultobj;
19809 int arg1 ;
19810 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19811 int arg3 = (int) wxDateTime::Inv_Year ;
19812 int arg4 = (int) 0 ;
19813 int arg5 = (int) 0 ;
19814 int arg6 = (int) 0 ;
19815 int arg7 = (int) 0 ;
19816 wxDateTime *result;
19817 PyObject * obj0 = 0 ;
19818 PyObject * obj1 = 0 ;
19819 PyObject * obj2 = 0 ;
19820 PyObject * obj3 = 0 ;
19821 PyObject * obj4 = 0 ;
19822 PyObject * obj5 = 0 ;
19823 PyObject * obj6 = 0 ;
19824 char *kwnames[] = {
19825 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19826 };
19827
19828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19829 {
19830 arg1 = (int)(SWIG_As_int(obj0));
19831 if (SWIG_arg_fail(1)) SWIG_fail;
19832 }
19833 if (obj1) {
19834 {
19835 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19836 if (SWIG_arg_fail(2)) SWIG_fail;
19837 }
19838 }
19839 if (obj2) {
19840 {
19841 arg3 = (int)(SWIG_As_int(obj2));
19842 if (SWIG_arg_fail(3)) SWIG_fail;
19843 }
19844 }
19845 if (obj3) {
19846 {
19847 arg4 = (int)(SWIG_As_int(obj3));
19848 if (SWIG_arg_fail(4)) SWIG_fail;
19849 }
19850 }
19851 if (obj4) {
19852 {
19853 arg5 = (int)(SWIG_As_int(obj4));
19854 if (SWIG_arg_fail(5)) SWIG_fail;
19855 }
19856 }
19857 if (obj5) {
19858 {
19859 arg6 = (int)(SWIG_As_int(obj5));
19860 if (SWIG_arg_fail(6)) SWIG_fail;
19861 }
19862 }
19863 if (obj6) {
19864 {
19865 arg7 = (int)(SWIG_As_int(obj6));
19866 if (SWIG_arg_fail(7)) SWIG_fail;
19867 }
19868 }
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19872
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj;
19885 wxDateTime *arg1 = (wxDateTime *) 0 ;
19886 PyObject * obj0 = 0 ;
19887 char *kwnames[] = {
19888 (char *) "self", NULL
19889 };
19890
19891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 {
19895 PyThreadState* __tstate = wxPyBeginAllowThreads();
19896 delete arg1;
19897
19898 wxPyEndAllowThreads(__tstate);
19899 if (PyErr_Occurred()) SWIG_fail;
19900 }
19901 Py_INCREF(Py_None); resultobj = Py_None;
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj;
19910 wxDateTime *arg1 = (wxDateTime *) 0 ;
19911 wxDateTime *result;
19912 PyObject * obj0 = 0 ;
19913 char *kwnames[] = {
19914 (char *) "self", NULL
19915 };
19916
19917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19919 if (SWIG_arg_fail(1)) SWIG_fail;
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 {
19923 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19924 result = (wxDateTime *) &_result_ref;
19925 }
19926
19927 wxPyEndAllowThreads(__tstate);
19928 if (PyErr_Occurred()) SWIG_fail;
19929 }
19930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19931 return resultobj;
19932 fail:
19933 return NULL;
19934 }
19935
19936
19937 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19938 PyObject *resultobj;
19939 wxDateTime *arg1 = (wxDateTime *) 0 ;
19940 time_t arg2 ;
19941 wxDateTime *result;
19942 PyObject * obj0 = 0 ;
19943 PyObject * obj1 = 0 ;
19944 char *kwnames[] = {
19945 (char *) "self",(char *) "timet", NULL
19946 };
19947
19948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19950 if (SWIG_arg_fail(1)) SWIG_fail;
19951 {
19952 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19953 if (SWIG_arg_fail(2)) SWIG_fail;
19954 }
19955 {
19956 PyThreadState* __tstate = wxPyBeginAllowThreads();
19957 {
19958 wxDateTime &_result_ref = (arg1)->Set(arg2);
19959 result = (wxDateTime *) &_result_ref;
19960 }
19961
19962 wxPyEndAllowThreads(__tstate);
19963 if (PyErr_Occurred()) SWIG_fail;
19964 }
19965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19966 return resultobj;
19967 fail:
19968 return NULL;
19969 }
19970
19971
19972 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19973 PyObject *resultobj;
19974 wxDateTime *arg1 = (wxDateTime *) 0 ;
19975 double arg2 ;
19976 wxDateTime *result;
19977 PyObject * obj0 = 0 ;
19978 PyObject * obj1 = 0 ;
19979 char *kwnames[] = {
19980 (char *) "self",(char *) "jdn", NULL
19981 };
19982
19983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19985 if (SWIG_arg_fail(1)) SWIG_fail;
19986 {
19987 arg2 = (double)(SWIG_As_double(obj1));
19988 if (SWIG_arg_fail(2)) SWIG_fail;
19989 }
19990 {
19991 PyThreadState* __tstate = wxPyBeginAllowThreads();
19992 {
19993 wxDateTime &_result_ref = (arg1)->Set(arg2);
19994 result = (wxDateTime *) &_result_ref;
19995 }
19996
19997 wxPyEndAllowThreads(__tstate);
19998 if (PyErr_Occurred()) SWIG_fail;
19999 }
20000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
20008 PyObject *resultobj;
20009 wxDateTime *arg1 = (wxDateTime *) 0 ;
20010 int arg2 ;
20011 int arg3 = (int) 0 ;
20012 int arg4 = (int) 0 ;
20013 int arg5 = (int) 0 ;
20014 wxDateTime *result;
20015 PyObject * obj0 = 0 ;
20016 PyObject * obj1 = 0 ;
20017 PyObject * obj2 = 0 ;
20018 PyObject * obj3 = 0 ;
20019 PyObject * obj4 = 0 ;
20020 char *kwnames[] = {
20021 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20022 };
20023
20024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20026 if (SWIG_arg_fail(1)) SWIG_fail;
20027 {
20028 arg2 = (int)(SWIG_As_int(obj1));
20029 if (SWIG_arg_fail(2)) SWIG_fail;
20030 }
20031 if (obj2) {
20032 {
20033 arg3 = (int)(SWIG_As_int(obj2));
20034 if (SWIG_arg_fail(3)) SWIG_fail;
20035 }
20036 }
20037 if (obj3) {
20038 {
20039 arg4 = (int)(SWIG_As_int(obj3));
20040 if (SWIG_arg_fail(4)) SWIG_fail;
20041 }
20042 }
20043 if (obj4) {
20044 {
20045 arg5 = (int)(SWIG_As_int(obj4));
20046 if (SWIG_arg_fail(5)) SWIG_fail;
20047 }
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 {
20052 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20053 result = (wxDateTime *) &_result_ref;
20054 }
20055
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20060 return resultobj;
20061 fail:
20062 return NULL;
20063 }
20064
20065
20066 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj;
20068 wxDateTime *arg1 = (wxDateTime *) 0 ;
20069 int arg2 ;
20070 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20071 int arg4 = (int) wxDateTime::Inv_Year ;
20072 int arg5 = (int) 0 ;
20073 int arg6 = (int) 0 ;
20074 int arg7 = (int) 0 ;
20075 int arg8 = (int) 0 ;
20076 wxDateTime *result;
20077 PyObject * obj0 = 0 ;
20078 PyObject * obj1 = 0 ;
20079 PyObject * obj2 = 0 ;
20080 PyObject * obj3 = 0 ;
20081 PyObject * obj4 = 0 ;
20082 PyObject * obj5 = 0 ;
20083 PyObject * obj6 = 0 ;
20084 PyObject * obj7 = 0 ;
20085 char *kwnames[] = {
20086 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20087 };
20088
20089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20091 if (SWIG_arg_fail(1)) SWIG_fail;
20092 {
20093 arg2 = (int)(SWIG_As_int(obj1));
20094 if (SWIG_arg_fail(2)) SWIG_fail;
20095 }
20096 if (obj2) {
20097 {
20098 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20099 if (SWIG_arg_fail(3)) SWIG_fail;
20100 }
20101 }
20102 if (obj3) {
20103 {
20104 arg4 = (int)(SWIG_As_int(obj3));
20105 if (SWIG_arg_fail(4)) SWIG_fail;
20106 }
20107 }
20108 if (obj4) {
20109 {
20110 arg5 = (int)(SWIG_As_int(obj4));
20111 if (SWIG_arg_fail(5)) SWIG_fail;
20112 }
20113 }
20114 if (obj5) {
20115 {
20116 arg6 = (int)(SWIG_As_int(obj5));
20117 if (SWIG_arg_fail(6)) SWIG_fail;
20118 }
20119 }
20120 if (obj6) {
20121 {
20122 arg7 = (int)(SWIG_As_int(obj6));
20123 if (SWIG_arg_fail(7)) SWIG_fail;
20124 }
20125 }
20126 if (obj7) {
20127 {
20128 arg8 = (int)(SWIG_As_int(obj7));
20129 if (SWIG_arg_fail(8)) SWIG_fail;
20130 }
20131 }
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 {
20135 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20136 result = (wxDateTime *) &_result_ref;
20137 }
20138
20139 wxPyEndAllowThreads(__tstate);
20140 if (PyErr_Occurred()) SWIG_fail;
20141 }
20142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20143 return resultobj;
20144 fail:
20145 return NULL;
20146 }
20147
20148
20149 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20150 PyObject *resultobj;
20151 wxDateTime *arg1 = (wxDateTime *) 0 ;
20152 wxDateTime *result;
20153 PyObject * obj0 = 0 ;
20154 char *kwnames[] = {
20155 (char *) "self", NULL
20156 };
20157
20158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20160 if (SWIG_arg_fail(1)) SWIG_fail;
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 {
20164 wxDateTime &_result_ref = (arg1)->ResetTime();
20165 result = (wxDateTime *) &_result_ref;
20166 }
20167
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20172 return resultobj;
20173 fail:
20174 return NULL;
20175 }
20176
20177
20178 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20179 PyObject *resultobj;
20180 wxDateTime *arg1 = (wxDateTime *) 0 ;
20181 int arg2 ;
20182 wxDateTime *result;
20183 PyObject * obj0 = 0 ;
20184 PyObject * obj1 = 0 ;
20185 char *kwnames[] = {
20186 (char *) "self",(char *) "year", NULL
20187 };
20188
20189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20191 if (SWIG_arg_fail(1)) SWIG_fail;
20192 {
20193 arg2 = (int)(SWIG_As_int(obj1));
20194 if (SWIG_arg_fail(2)) SWIG_fail;
20195 }
20196 {
20197 PyThreadState* __tstate = wxPyBeginAllowThreads();
20198 {
20199 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20200 result = (wxDateTime *) &_result_ref;
20201 }
20202
20203 wxPyEndAllowThreads(__tstate);
20204 if (PyErr_Occurred()) SWIG_fail;
20205 }
20206 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20207 return resultobj;
20208 fail:
20209 return NULL;
20210 }
20211
20212
20213 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20214 PyObject *resultobj;
20215 wxDateTime *arg1 = (wxDateTime *) 0 ;
20216 wxDateTime::Month arg2 ;
20217 wxDateTime *result;
20218 PyObject * obj0 = 0 ;
20219 PyObject * obj1 = 0 ;
20220 char *kwnames[] = {
20221 (char *) "self",(char *) "month", NULL
20222 };
20223
20224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20226 if (SWIG_arg_fail(1)) SWIG_fail;
20227 {
20228 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20229 if (SWIG_arg_fail(2)) SWIG_fail;
20230 }
20231 {
20232 PyThreadState* __tstate = wxPyBeginAllowThreads();
20233 {
20234 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20235 result = (wxDateTime *) &_result_ref;
20236 }
20237
20238 wxPyEndAllowThreads(__tstate);
20239 if (PyErr_Occurred()) SWIG_fail;
20240 }
20241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20249 PyObject *resultobj;
20250 wxDateTime *arg1 = (wxDateTime *) 0 ;
20251 int arg2 ;
20252 wxDateTime *result;
20253 PyObject * obj0 = 0 ;
20254 PyObject * obj1 = 0 ;
20255 char *kwnames[] = {
20256 (char *) "self",(char *) "day", NULL
20257 };
20258
20259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20261 if (SWIG_arg_fail(1)) SWIG_fail;
20262 {
20263 arg2 = (int)(SWIG_As_int(obj1));
20264 if (SWIG_arg_fail(2)) SWIG_fail;
20265 }
20266 {
20267 PyThreadState* __tstate = wxPyBeginAllowThreads();
20268 {
20269 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20270 result = (wxDateTime *) &_result_ref;
20271 }
20272
20273 wxPyEndAllowThreads(__tstate);
20274 if (PyErr_Occurred()) SWIG_fail;
20275 }
20276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20277 return resultobj;
20278 fail:
20279 return NULL;
20280 }
20281
20282
20283 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20284 PyObject *resultobj;
20285 wxDateTime *arg1 = (wxDateTime *) 0 ;
20286 int arg2 ;
20287 wxDateTime *result;
20288 PyObject * obj0 = 0 ;
20289 PyObject * obj1 = 0 ;
20290 char *kwnames[] = {
20291 (char *) "self",(char *) "hour", NULL
20292 };
20293
20294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20296 if (SWIG_arg_fail(1)) SWIG_fail;
20297 {
20298 arg2 = (int)(SWIG_As_int(obj1));
20299 if (SWIG_arg_fail(2)) SWIG_fail;
20300 }
20301 {
20302 PyThreadState* __tstate = wxPyBeginAllowThreads();
20303 {
20304 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20305 result = (wxDateTime *) &_result_ref;
20306 }
20307
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20319 PyObject *resultobj;
20320 wxDateTime *arg1 = (wxDateTime *) 0 ;
20321 int arg2 ;
20322 wxDateTime *result;
20323 PyObject * obj0 = 0 ;
20324 PyObject * obj1 = 0 ;
20325 char *kwnames[] = {
20326 (char *) "self",(char *) "minute", NULL
20327 };
20328
20329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20331 if (SWIG_arg_fail(1)) SWIG_fail;
20332 {
20333 arg2 = (int)(SWIG_As_int(obj1));
20334 if (SWIG_arg_fail(2)) SWIG_fail;
20335 }
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 {
20339 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20340 result = (wxDateTime *) &_result_ref;
20341 }
20342
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20347 return resultobj;
20348 fail:
20349 return NULL;
20350 }
20351
20352
20353 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20354 PyObject *resultobj;
20355 wxDateTime *arg1 = (wxDateTime *) 0 ;
20356 int arg2 ;
20357 wxDateTime *result;
20358 PyObject * obj0 = 0 ;
20359 PyObject * obj1 = 0 ;
20360 char *kwnames[] = {
20361 (char *) "self",(char *) "second", NULL
20362 };
20363
20364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20366 if (SWIG_arg_fail(1)) SWIG_fail;
20367 {
20368 arg2 = (int)(SWIG_As_int(obj1));
20369 if (SWIG_arg_fail(2)) SWIG_fail;
20370 }
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 {
20374 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20375 result = (wxDateTime *) &_result_ref;
20376 }
20377
20378 wxPyEndAllowThreads(__tstate);
20379 if (PyErr_Occurred()) SWIG_fail;
20380 }
20381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20382 return resultobj;
20383 fail:
20384 return NULL;
20385 }
20386
20387
20388 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20389 PyObject *resultobj;
20390 wxDateTime *arg1 = (wxDateTime *) 0 ;
20391 int arg2 ;
20392 wxDateTime *result;
20393 PyObject * obj0 = 0 ;
20394 PyObject * obj1 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self",(char *) "millisecond", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 arg2 = (int)(SWIG_As_int(obj1));
20404 if (SWIG_arg_fail(2)) SWIG_fail;
20405 }
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 {
20409 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20410 result = (wxDateTime *) &_result_ref;
20411 }
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20424 PyObject *resultobj;
20425 wxDateTime *arg1 = (wxDateTime *) 0 ;
20426 wxDateTime::WeekDay arg2 ;
20427 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20428 wxDateTime *result;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 PyObject * obj2 = 0 ;
20432 char *kwnames[] = {
20433 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20434 };
20435
20436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20438 if (SWIG_arg_fail(1)) SWIG_fail;
20439 {
20440 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20441 if (SWIG_arg_fail(2)) SWIG_fail;
20442 }
20443 if (obj2) {
20444 {
20445 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20446 if (SWIG_arg_fail(3)) SWIG_fail;
20447 }
20448 }
20449 {
20450 PyThreadState* __tstate = wxPyBeginAllowThreads();
20451 {
20452 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20453 result = (wxDateTime *) &_result_ref;
20454 }
20455
20456 wxPyEndAllowThreads(__tstate);
20457 if (PyErr_Occurred()) SWIG_fail;
20458 }
20459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20467 PyObject *resultobj;
20468 wxDateTime *arg1 = (wxDateTime *) 0 ;
20469 wxDateTime::WeekDay arg2 ;
20470 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20471 wxDateTime result;
20472 PyObject * obj0 = 0 ;
20473 PyObject * obj1 = 0 ;
20474 PyObject * obj2 = 0 ;
20475 char *kwnames[] = {
20476 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20477 };
20478
20479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20481 if (SWIG_arg_fail(1)) SWIG_fail;
20482 {
20483 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20484 if (SWIG_arg_fail(2)) SWIG_fail;
20485 }
20486 if (obj2) {
20487 {
20488 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20489 if (SWIG_arg_fail(3)) SWIG_fail;
20490 }
20491 }
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20495
20496 wxPyEndAllowThreads(__tstate);
20497 if (PyErr_Occurred()) SWIG_fail;
20498 }
20499 {
20500 wxDateTime * resultptr;
20501 resultptr = new wxDateTime((wxDateTime &)(result));
20502 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20503 }
20504 return resultobj;
20505 fail:
20506 return NULL;
20507 }
20508
20509
20510 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20511 PyObject *resultobj;
20512 wxDateTime *arg1 = (wxDateTime *) 0 ;
20513 wxDateTime::WeekDay arg2 ;
20514 wxDateTime *result;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 char *kwnames[] = {
20518 (char *) "self",(char *) "weekday", NULL
20519 };
20520
20521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20523 if (SWIG_arg_fail(1)) SWIG_fail;
20524 {
20525 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20526 if (SWIG_arg_fail(2)) SWIG_fail;
20527 }
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 {
20531 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20532 result = (wxDateTime *) &_result_ref;
20533 }
20534
20535 wxPyEndAllowThreads(__tstate);
20536 if (PyErr_Occurred()) SWIG_fail;
20537 }
20538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20546 PyObject *resultobj;
20547 wxDateTime *arg1 = (wxDateTime *) 0 ;
20548 wxDateTime::WeekDay arg2 ;
20549 wxDateTime result;
20550 PyObject * obj0 = 0 ;
20551 PyObject * obj1 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "self",(char *) "weekday", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20558 if (SWIG_arg_fail(1)) SWIG_fail;
20559 {
20560 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20561 if (SWIG_arg_fail(2)) SWIG_fail;
20562 }
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20566
20567 wxPyEndAllowThreads(__tstate);
20568 if (PyErr_Occurred()) SWIG_fail;
20569 }
20570 {
20571 wxDateTime * resultptr;
20572 resultptr = new wxDateTime((wxDateTime &)(result));
20573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20574 }
20575 return resultobj;
20576 fail:
20577 return NULL;
20578 }
20579
20580
20581 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20582 PyObject *resultobj;
20583 wxDateTime *arg1 = (wxDateTime *) 0 ;
20584 wxDateTime::WeekDay arg2 ;
20585 wxDateTime *result;
20586 PyObject * obj0 = 0 ;
20587 PyObject * obj1 = 0 ;
20588 char *kwnames[] = {
20589 (char *) "self",(char *) "weekday", NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 {
20596 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20597 if (SWIG_arg_fail(2)) SWIG_fail;
20598 }
20599 {
20600 PyThreadState* __tstate = wxPyBeginAllowThreads();
20601 {
20602 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20603 result = (wxDateTime *) &_result_ref;
20604 }
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj;
20618 wxDateTime *arg1 = (wxDateTime *) 0 ;
20619 wxDateTime::WeekDay arg2 ;
20620 wxDateTime result;
20621 PyObject * obj0 = 0 ;
20622 PyObject * obj1 = 0 ;
20623 char *kwnames[] = {
20624 (char *) "self",(char *) "weekday", NULL
20625 };
20626
20627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20629 if (SWIG_arg_fail(1)) SWIG_fail;
20630 {
20631 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20632 if (SWIG_arg_fail(2)) SWIG_fail;
20633 }
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 {
20642 wxDateTime * resultptr;
20643 resultptr = new wxDateTime((wxDateTime &)(result));
20644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20645 }
20646 return resultobj;
20647 fail:
20648 return NULL;
20649 }
20650
20651
20652 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20653 PyObject *resultobj;
20654 wxDateTime *arg1 = (wxDateTime *) 0 ;
20655 wxDateTime::WeekDay arg2 ;
20656 int arg3 = (int) 1 ;
20657 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20658 int arg5 = (int) wxDateTime::Inv_Year ;
20659 bool result;
20660 PyObject * obj0 = 0 ;
20661 PyObject * obj1 = 0 ;
20662 PyObject * obj2 = 0 ;
20663 PyObject * obj3 = 0 ;
20664 PyObject * obj4 = 0 ;
20665 char *kwnames[] = {
20666 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20667 };
20668
20669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20671 if (SWIG_arg_fail(1)) SWIG_fail;
20672 {
20673 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20674 if (SWIG_arg_fail(2)) SWIG_fail;
20675 }
20676 if (obj2) {
20677 {
20678 arg3 = (int)(SWIG_As_int(obj2));
20679 if (SWIG_arg_fail(3)) SWIG_fail;
20680 }
20681 }
20682 if (obj3) {
20683 {
20684 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20685 if (SWIG_arg_fail(4)) SWIG_fail;
20686 }
20687 }
20688 if (obj4) {
20689 {
20690 arg5 = (int)(SWIG_As_int(obj4));
20691 if (SWIG_arg_fail(5)) SWIG_fail;
20692 }
20693 }
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20697
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 {
20702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20703 }
20704 return resultobj;
20705 fail:
20706 return NULL;
20707 }
20708
20709
20710 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20711 PyObject *resultobj;
20712 wxDateTime *arg1 = (wxDateTime *) 0 ;
20713 wxDateTime::WeekDay arg2 ;
20714 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20715 int arg4 = (int) wxDateTime::Inv_Year ;
20716 bool result;
20717 PyObject * obj0 = 0 ;
20718 PyObject * obj1 = 0 ;
20719 PyObject * obj2 = 0 ;
20720 PyObject * obj3 = 0 ;
20721 char *kwnames[] = {
20722 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20723 };
20724
20725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 {
20729 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20730 if (SWIG_arg_fail(2)) SWIG_fail;
20731 }
20732 if (obj2) {
20733 {
20734 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20735 if (SWIG_arg_fail(3)) SWIG_fail;
20736 }
20737 }
20738 if (obj3) {
20739 {
20740 arg4 = (int)(SWIG_As_int(obj3));
20741 if (SWIG_arg_fail(4)) SWIG_fail;
20742 }
20743 }
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20747
20748 wxPyEndAllowThreads(__tstate);
20749 if (PyErr_Occurred()) SWIG_fail;
20750 }
20751 {
20752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20753 }
20754 return resultobj;
20755 fail:
20756 return NULL;
20757 }
20758
20759
20760 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20761 PyObject *resultobj;
20762 wxDateTime *arg1 = (wxDateTime *) 0 ;
20763 wxDateTime::WeekDay arg2 ;
20764 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20765 int arg4 = (int) wxDateTime::Inv_Year ;
20766 wxDateTime result;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 PyObject * obj2 = 0 ;
20770 PyObject * obj3 = 0 ;
20771 char *kwnames[] = {
20772 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20773 };
20774
20775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20777 if (SWIG_arg_fail(1)) SWIG_fail;
20778 {
20779 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20780 if (SWIG_arg_fail(2)) SWIG_fail;
20781 }
20782 if (obj2) {
20783 {
20784 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20785 if (SWIG_arg_fail(3)) SWIG_fail;
20786 }
20787 }
20788 if (obj3) {
20789 {
20790 arg4 = (int)(SWIG_As_int(obj3));
20791 if (SWIG_arg_fail(4)) SWIG_fail;
20792 }
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 {
20802 wxDateTime * resultptr;
20803 resultptr = new wxDateTime((wxDateTime &)(result));
20804 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20805 }
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20813 PyObject *resultobj;
20814 wxDateTime *arg1 = (wxDateTime *) 0 ;
20815 int arg2 ;
20816 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20817 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20818 bool result;
20819 PyObject * obj0 = 0 ;
20820 PyObject * obj1 = 0 ;
20821 PyObject * obj2 = 0 ;
20822 PyObject * obj3 = 0 ;
20823 char *kwnames[] = {
20824 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20825 };
20826
20827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20829 if (SWIG_arg_fail(1)) SWIG_fail;
20830 {
20831 arg2 = (int)(SWIG_As_int(obj1));
20832 if (SWIG_arg_fail(2)) SWIG_fail;
20833 }
20834 if (obj2) {
20835 {
20836 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20837 if (SWIG_arg_fail(3)) SWIG_fail;
20838 }
20839 }
20840 if (obj3) {
20841 {
20842 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20843 if (SWIG_arg_fail(4)) SWIG_fail;
20844 }
20845 }
20846 {
20847 PyThreadState* __tstate = wxPyBeginAllowThreads();
20848 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20849
20850 wxPyEndAllowThreads(__tstate);
20851 if (PyErr_Occurred()) SWIG_fail;
20852 }
20853 {
20854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20855 }
20856 return resultobj;
20857 fail:
20858 return NULL;
20859 }
20860
20861
20862 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20863 PyObject *resultobj;
20864 wxDateTime *arg1 = (wxDateTime *) 0 ;
20865 int arg2 ;
20866 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20867 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20868 wxDateTime result;
20869 PyObject * obj0 = 0 ;
20870 PyObject * obj1 = 0 ;
20871 PyObject * obj2 = 0 ;
20872 PyObject * obj3 = 0 ;
20873 char *kwnames[] = {
20874 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20875 };
20876
20877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20879 if (SWIG_arg_fail(1)) SWIG_fail;
20880 {
20881 arg2 = (int)(SWIG_As_int(obj1));
20882 if (SWIG_arg_fail(2)) SWIG_fail;
20883 }
20884 if (obj2) {
20885 {
20886 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20887 if (SWIG_arg_fail(3)) SWIG_fail;
20888 }
20889 }
20890 if (obj3) {
20891 {
20892 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20893 if (SWIG_arg_fail(4)) SWIG_fail;
20894 }
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20899
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 {
20904 wxDateTime * resultptr;
20905 resultptr = new wxDateTime((wxDateTime &)(result));
20906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20907 }
20908 return resultobj;
20909 fail:
20910 return NULL;
20911 }
20912
20913
20914 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20915 PyObject *resultobj;
20916 int arg1 ;
20917 int arg2 ;
20918 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20919 wxDateTime result;
20920 PyObject * obj0 = 0 ;
20921 PyObject * obj1 = 0 ;
20922 PyObject * obj2 = 0 ;
20923 char *kwnames[] = {
20924 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20925 };
20926
20927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20928 {
20929 arg1 = (int)(SWIG_As_int(obj0));
20930 if (SWIG_arg_fail(1)) SWIG_fail;
20931 }
20932 {
20933 arg2 = (int)(SWIG_As_int(obj1));
20934 if (SWIG_arg_fail(2)) SWIG_fail;
20935 }
20936 if (obj2) {
20937 {
20938 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20939 if (SWIG_arg_fail(3)) SWIG_fail;
20940 }
20941 }
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20945
20946 wxPyEndAllowThreads(__tstate);
20947 if (PyErr_Occurred()) SWIG_fail;
20948 }
20949 {
20950 wxDateTime * resultptr;
20951 resultptr = new wxDateTime((wxDateTime &)(result));
20952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20953 }
20954 return resultobj;
20955 fail:
20956 return NULL;
20957 }
20958
20959
20960 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20961 PyObject *resultobj;
20962 wxDateTime *arg1 = (wxDateTime *) 0 ;
20963 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20964 int arg3 = (int) wxDateTime::Inv_Year ;
20965 wxDateTime *result;
20966 PyObject * obj0 = 0 ;
20967 PyObject * obj1 = 0 ;
20968 PyObject * obj2 = 0 ;
20969 char *kwnames[] = {
20970 (char *) "self",(char *) "month",(char *) "year", NULL
20971 };
20972
20973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20975 if (SWIG_arg_fail(1)) SWIG_fail;
20976 if (obj1) {
20977 {
20978 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 }
20981 }
20982 if (obj2) {
20983 {
20984 arg3 = (int)(SWIG_As_int(obj2));
20985 if (SWIG_arg_fail(3)) SWIG_fail;
20986 }
20987 }
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 {
20991 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20992 result = (wxDateTime *) &_result_ref;
20993 }
20994
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
21006 PyObject *resultobj;
21007 wxDateTime *arg1 = (wxDateTime *) 0 ;
21008 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
21009 int arg3 = (int) wxDateTime::Inv_Year ;
21010 wxDateTime result;
21011 PyObject * obj0 = 0 ;
21012 PyObject * obj1 = 0 ;
21013 PyObject * obj2 = 0 ;
21014 char *kwnames[] = {
21015 (char *) "self",(char *) "month",(char *) "year", NULL
21016 };
21017
21018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
21019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21020 if (SWIG_arg_fail(1)) SWIG_fail;
21021 if (obj1) {
21022 {
21023 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
21024 if (SWIG_arg_fail(2)) SWIG_fail;
21025 }
21026 }
21027 if (obj2) {
21028 {
21029 arg3 = (int)(SWIG_As_int(obj2));
21030 if (SWIG_arg_fail(3)) SWIG_fail;
21031 }
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21036
21037 wxPyEndAllowThreads(__tstate);
21038 if (PyErr_Occurred()) SWIG_fail;
21039 }
21040 {
21041 wxDateTime * resultptr;
21042 resultptr = new wxDateTime((wxDateTime &)(result));
21043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21044 }
21045 return resultobj;
21046 fail:
21047 return NULL;
21048 }
21049
21050
21051 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21052 PyObject *resultobj;
21053 wxDateTime *arg1 = (wxDateTime *) 0 ;
21054 int arg2 ;
21055 wxDateTime *result;
21056 PyObject * obj0 = 0 ;
21057 PyObject * obj1 = 0 ;
21058 char *kwnames[] = {
21059 (char *) "self",(char *) "yday", NULL
21060 };
21061
21062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21064 if (SWIG_arg_fail(1)) SWIG_fail;
21065 {
21066 arg2 = (int)(SWIG_As_int(obj1));
21067 if (SWIG_arg_fail(2)) SWIG_fail;
21068 }
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 {
21072 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21073 result = (wxDateTime *) &_result_ref;
21074 }
21075
21076 wxPyEndAllowThreads(__tstate);
21077 if (PyErr_Occurred()) SWIG_fail;
21078 }
21079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxDateTime *arg1 = (wxDateTime *) 0 ;
21089 int arg2 ;
21090 wxDateTime result;
21091 PyObject * obj0 = 0 ;
21092 PyObject * obj1 = 0 ;
21093 char *kwnames[] = {
21094 (char *) "self",(char *) "yday", NULL
21095 };
21096
21097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21099 if (SWIG_arg_fail(1)) SWIG_fail;
21100 {
21101 arg2 = (int)(SWIG_As_int(obj1));
21102 if (SWIG_arg_fail(2)) SWIG_fail;
21103 }
21104 {
21105 PyThreadState* __tstate = wxPyBeginAllowThreads();
21106 result = (arg1)->GetYearDay(arg2);
21107
21108 wxPyEndAllowThreads(__tstate);
21109 if (PyErr_Occurred()) SWIG_fail;
21110 }
21111 {
21112 wxDateTime * resultptr;
21113 resultptr = new wxDateTime((wxDateTime &)(result));
21114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21115 }
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21123 PyObject *resultobj;
21124 wxDateTime *arg1 = (wxDateTime *) 0 ;
21125 double result;
21126 PyObject * obj0 = 0 ;
21127 char *kwnames[] = {
21128 (char *) "self", NULL
21129 };
21130
21131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21133 if (SWIG_arg_fail(1)) SWIG_fail;
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (double)(arg1)->GetJulianDayNumber();
21137
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 {
21142 resultobj = SWIG_From_double((double)(result));
21143 }
21144 return resultobj;
21145 fail:
21146 return NULL;
21147 }
21148
21149
21150 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21151 PyObject *resultobj;
21152 wxDateTime *arg1 = (wxDateTime *) 0 ;
21153 double result;
21154 PyObject * obj0 = 0 ;
21155 char *kwnames[] = {
21156 (char *) "self", NULL
21157 };
21158
21159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21161 if (SWIG_arg_fail(1)) SWIG_fail;
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (double)(arg1)->GetJDN();
21165
21166 wxPyEndAllowThreads(__tstate);
21167 if (PyErr_Occurred()) SWIG_fail;
21168 }
21169 {
21170 resultobj = SWIG_From_double((double)(result));
21171 }
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21179 PyObject *resultobj;
21180 wxDateTime *arg1 = (wxDateTime *) 0 ;
21181 double result;
21182 PyObject * obj0 = 0 ;
21183 char *kwnames[] = {
21184 (char *) "self", NULL
21185 };
21186
21187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21189 if (SWIG_arg_fail(1)) SWIG_fail;
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21193
21194 wxPyEndAllowThreads(__tstate);
21195 if (PyErr_Occurred()) SWIG_fail;
21196 }
21197 {
21198 resultobj = SWIG_From_double((double)(result));
21199 }
21200 return resultobj;
21201 fail:
21202 return NULL;
21203 }
21204
21205
21206 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21207 PyObject *resultobj;
21208 wxDateTime *arg1 = (wxDateTime *) 0 ;
21209 double result;
21210 PyObject * obj0 = 0 ;
21211 char *kwnames[] = {
21212 (char *) "self", NULL
21213 };
21214
21215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21217 if (SWIG_arg_fail(1)) SWIG_fail;
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (double)(arg1)->GetMJD();
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 {
21226 resultobj = SWIG_From_double((double)(result));
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxDateTime *arg1 = (wxDateTime *) 0 ;
21237 double result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (double)(arg1)->GetRataDie();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = SWIG_From_double((double)(result));
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21263 PyObject *resultobj;
21264 wxDateTime *arg1 = (wxDateTime *) 0 ;
21265 wxDateTime::TimeZone *arg2 = 0 ;
21266 bool arg3 = (bool) false ;
21267 wxDateTime result;
21268 bool temp2 = false ;
21269 PyObject * obj0 = 0 ;
21270 PyObject * obj1 = 0 ;
21271 PyObject * obj2 = 0 ;
21272 char *kwnames[] = {
21273 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21274 };
21275
21276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21278 if (SWIG_arg_fail(1)) SWIG_fail;
21279 {
21280 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21281 temp2 = true;
21282 }
21283 if (obj2) {
21284 {
21285 arg3 = (bool)(SWIG_As_bool(obj2));
21286 if (SWIG_arg_fail(3)) SWIG_fail;
21287 }
21288 }
21289 {
21290 PyThreadState* __tstate = wxPyBeginAllowThreads();
21291 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21292
21293 wxPyEndAllowThreads(__tstate);
21294 if (PyErr_Occurred()) SWIG_fail;
21295 }
21296 {
21297 wxDateTime * resultptr;
21298 resultptr = new wxDateTime((wxDateTime &)(result));
21299 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21300 }
21301 {
21302 if (temp2) delete arg2;
21303 }
21304 return resultobj;
21305 fail:
21306 {
21307 if (temp2) delete arg2;
21308 }
21309 return NULL;
21310 }
21311
21312
21313 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21314 PyObject *resultobj;
21315 wxDateTime *arg1 = (wxDateTime *) 0 ;
21316 wxDateTime::TimeZone *arg2 = 0 ;
21317 bool arg3 = (bool) false ;
21318 wxDateTime *result;
21319 bool temp2 = false ;
21320 PyObject * obj0 = 0 ;
21321 PyObject * obj1 = 0 ;
21322 PyObject * obj2 = 0 ;
21323 char *kwnames[] = {
21324 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21325 };
21326
21327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(1)) SWIG_fail;
21330 {
21331 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21332 temp2 = true;
21333 }
21334 if (obj2) {
21335 {
21336 arg3 = (bool)(SWIG_As_bool(obj2));
21337 if (SWIG_arg_fail(3)) SWIG_fail;
21338 }
21339 }
21340 {
21341 PyThreadState* __tstate = wxPyBeginAllowThreads();
21342 {
21343 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21344 result = (wxDateTime *) &_result_ref;
21345 }
21346
21347 wxPyEndAllowThreads(__tstate);
21348 if (PyErr_Occurred()) SWIG_fail;
21349 }
21350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21351 {
21352 if (temp2) delete arg2;
21353 }
21354 return resultobj;
21355 fail:
21356 {
21357 if (temp2) delete arg2;
21358 }
21359 return NULL;
21360 }
21361
21362
21363 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21364 PyObject *resultobj;
21365 wxDateTime *arg1 = (wxDateTime *) 0 ;
21366 bool arg2 = (bool) false ;
21367 wxDateTime result;
21368 PyObject * obj0 = 0 ;
21369 PyObject * obj1 = 0 ;
21370 char *kwnames[] = {
21371 (char *) "self",(char *) "noDST", NULL
21372 };
21373
21374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21376 if (SWIG_arg_fail(1)) SWIG_fail;
21377 if (obj1) {
21378 {
21379 arg2 = (bool)(SWIG_As_bool(obj1));
21380 if (SWIG_arg_fail(2)) SWIG_fail;
21381 }
21382 }
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (arg1)->ToGMT(arg2);
21386
21387 wxPyEndAllowThreads(__tstate);
21388 if (PyErr_Occurred()) SWIG_fail;
21389 }
21390 {
21391 wxDateTime * resultptr;
21392 resultptr = new wxDateTime((wxDateTime &)(result));
21393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21394 }
21395 return resultobj;
21396 fail:
21397 return NULL;
21398 }
21399
21400
21401 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21402 PyObject *resultobj;
21403 wxDateTime *arg1 = (wxDateTime *) 0 ;
21404 bool arg2 = (bool) false ;
21405 wxDateTime *result;
21406 PyObject * obj0 = 0 ;
21407 PyObject * obj1 = 0 ;
21408 char *kwnames[] = {
21409 (char *) "self",(char *) "noDST", NULL
21410 };
21411
21412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21414 if (SWIG_arg_fail(1)) SWIG_fail;
21415 if (obj1) {
21416 {
21417 arg2 = (bool)(SWIG_As_bool(obj1));
21418 if (SWIG_arg_fail(2)) SWIG_fail;
21419 }
21420 }
21421 {
21422 PyThreadState* __tstate = wxPyBeginAllowThreads();
21423 {
21424 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21425 result = (wxDateTime *) &_result_ref;
21426 }
21427
21428 wxPyEndAllowThreads(__tstate);
21429 if (PyErr_Occurred()) SWIG_fail;
21430 }
21431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj;
21440 wxDateTime *arg1 = (wxDateTime *) 0 ;
21441 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21442 int result;
21443 PyObject * obj0 = 0 ;
21444 PyObject * obj1 = 0 ;
21445 char *kwnames[] = {
21446 (char *) "self",(char *) "country", NULL
21447 };
21448
21449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21451 if (SWIG_arg_fail(1)) SWIG_fail;
21452 if (obj1) {
21453 {
21454 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21455 if (SWIG_arg_fail(2)) SWIG_fail;
21456 }
21457 }
21458 {
21459 PyThreadState* __tstate = wxPyBeginAllowThreads();
21460 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21461
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 {
21466 resultobj = SWIG_From_int((int)(result));
21467 }
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21475 PyObject *resultobj;
21476 wxDateTime *arg1 = (wxDateTime *) 0 ;
21477 bool result;
21478 PyObject * obj0 = 0 ;
21479 char *kwnames[] = {
21480 (char *) "self", NULL
21481 };
21482
21483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21485 if (SWIG_arg_fail(1)) SWIG_fail;
21486 {
21487 PyThreadState* __tstate = wxPyBeginAllowThreads();
21488 result = (bool)((wxDateTime const *)arg1)->IsValid();
21489
21490 wxPyEndAllowThreads(__tstate);
21491 if (PyErr_Occurred()) SWIG_fail;
21492 }
21493 {
21494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21495 }
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21503 PyObject *resultobj;
21504 wxDateTime *arg1 = (wxDateTime *) 0 ;
21505 time_t result;
21506 PyObject * obj0 = 0 ;
21507 char *kwnames[] = {
21508 (char *) "self", NULL
21509 };
21510
21511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21513 if (SWIG_arg_fail(1)) SWIG_fail;
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 {
21522 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21523 }
21524 return resultobj;
21525 fail:
21526 return NULL;
21527 }
21528
21529
21530 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj;
21532 wxDateTime *arg1 = (wxDateTime *) 0 ;
21533 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21534 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21535 int result;
21536 bool temp2 = false ;
21537 PyObject * obj0 = 0 ;
21538 PyObject * obj1 = 0 ;
21539 char *kwnames[] = {
21540 (char *) "self",(char *) "tz", NULL
21541 };
21542
21543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21545 if (SWIG_arg_fail(1)) SWIG_fail;
21546 if (obj1) {
21547 {
21548 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21549 temp2 = true;
21550 }
21551 }
21552 {
21553 PyThreadState* __tstate = wxPyBeginAllowThreads();
21554 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21555
21556 wxPyEndAllowThreads(__tstate);
21557 if (PyErr_Occurred()) SWIG_fail;
21558 }
21559 {
21560 resultobj = SWIG_From_int((int)(result));
21561 }
21562 {
21563 if (temp2) delete arg2;
21564 }
21565 return resultobj;
21566 fail:
21567 {
21568 if (temp2) delete arg2;
21569 }
21570 return NULL;
21571 }
21572
21573
21574 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21575 PyObject *resultobj;
21576 wxDateTime *arg1 = (wxDateTime *) 0 ;
21577 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21578 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21579 wxDateTime::Month result;
21580 bool temp2 = false ;
21581 PyObject * obj0 = 0 ;
21582 PyObject * obj1 = 0 ;
21583 char *kwnames[] = {
21584 (char *) "self",(char *) "tz", NULL
21585 };
21586
21587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21589 if (SWIG_arg_fail(1)) SWIG_fail;
21590 if (obj1) {
21591 {
21592 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21593 temp2 = true;
21594 }
21595 }
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 resultobj = SWIG_From_int((result));
21604 {
21605 if (temp2) delete arg2;
21606 }
21607 return resultobj;
21608 fail:
21609 {
21610 if (temp2) delete arg2;
21611 }
21612 return NULL;
21613 }
21614
21615
21616 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj;
21618 wxDateTime *arg1 = (wxDateTime *) 0 ;
21619 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21620 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21621 int result;
21622 bool temp2 = false ;
21623 PyObject * obj0 = 0 ;
21624 PyObject * obj1 = 0 ;
21625 char *kwnames[] = {
21626 (char *) "self",(char *) "tz", NULL
21627 };
21628
21629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21631 if (SWIG_arg_fail(1)) SWIG_fail;
21632 if (obj1) {
21633 {
21634 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21635 temp2 = true;
21636 }
21637 }
21638 {
21639 PyThreadState* __tstate = wxPyBeginAllowThreads();
21640 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21641
21642 wxPyEndAllowThreads(__tstate);
21643 if (PyErr_Occurred()) SWIG_fail;
21644 }
21645 {
21646 resultobj = SWIG_From_int((int)(result));
21647 }
21648 {
21649 if (temp2) delete arg2;
21650 }
21651 return resultobj;
21652 fail:
21653 {
21654 if (temp2) delete arg2;
21655 }
21656 return NULL;
21657 }
21658
21659
21660 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21661 PyObject *resultobj;
21662 wxDateTime *arg1 = (wxDateTime *) 0 ;
21663 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21664 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21665 wxDateTime::WeekDay result;
21666 bool temp2 = false ;
21667 PyObject * obj0 = 0 ;
21668 PyObject * obj1 = 0 ;
21669 char *kwnames[] = {
21670 (char *) "self",(char *) "tz", NULL
21671 };
21672
21673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21675 if (SWIG_arg_fail(1)) SWIG_fail;
21676 if (obj1) {
21677 {
21678 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21679 temp2 = true;
21680 }
21681 }
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21685
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_From_int((result));
21690 {
21691 if (temp2) delete arg2;
21692 }
21693 return resultobj;
21694 fail:
21695 {
21696 if (temp2) delete arg2;
21697 }
21698 return NULL;
21699 }
21700
21701
21702 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21703 PyObject *resultobj;
21704 wxDateTime *arg1 = (wxDateTime *) 0 ;
21705 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21706 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21707 int result;
21708 bool temp2 = false ;
21709 PyObject * obj0 = 0 ;
21710 PyObject * obj1 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self",(char *) "tz", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 if (obj1) {
21719 {
21720 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21721 temp2 = true;
21722 }
21723 }
21724 {
21725 PyThreadState* __tstate = wxPyBeginAllowThreads();
21726 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21727
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 {
21732 resultobj = SWIG_From_int((int)(result));
21733 }
21734 {
21735 if (temp2) delete arg2;
21736 }
21737 return resultobj;
21738 fail:
21739 {
21740 if (temp2) delete arg2;
21741 }
21742 return NULL;
21743 }
21744
21745
21746 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21747 PyObject *resultobj;
21748 wxDateTime *arg1 = (wxDateTime *) 0 ;
21749 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21750 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21751 int result;
21752 bool temp2 = false ;
21753 PyObject * obj0 = 0 ;
21754 PyObject * obj1 = 0 ;
21755 char *kwnames[] = {
21756 (char *) "self",(char *) "tz", NULL
21757 };
21758
21759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21761 if (SWIG_arg_fail(1)) SWIG_fail;
21762 if (obj1) {
21763 {
21764 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21765 temp2 = true;
21766 }
21767 }
21768 {
21769 PyThreadState* __tstate = wxPyBeginAllowThreads();
21770 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21771
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 {
21776 resultobj = SWIG_From_int((int)(result));
21777 }
21778 {
21779 if (temp2) delete arg2;
21780 }
21781 return resultobj;
21782 fail:
21783 {
21784 if (temp2) delete arg2;
21785 }
21786 return NULL;
21787 }
21788
21789
21790 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21791 PyObject *resultobj;
21792 wxDateTime *arg1 = (wxDateTime *) 0 ;
21793 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21794 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21795 int result;
21796 bool temp2 = false ;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self",(char *) "tz", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 if (obj1) {
21807 {
21808 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21809 temp2 = true;
21810 }
21811 }
21812 {
21813 PyThreadState* __tstate = wxPyBeginAllowThreads();
21814 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21815
21816 wxPyEndAllowThreads(__tstate);
21817 if (PyErr_Occurred()) SWIG_fail;
21818 }
21819 {
21820 resultobj = SWIG_From_int((int)(result));
21821 }
21822 {
21823 if (temp2) delete arg2;
21824 }
21825 return resultobj;
21826 fail:
21827 {
21828 if (temp2) delete arg2;
21829 }
21830 return NULL;
21831 }
21832
21833
21834 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21835 PyObject *resultobj;
21836 wxDateTime *arg1 = (wxDateTime *) 0 ;
21837 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21838 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21839 int result;
21840 bool temp2 = false ;
21841 PyObject * obj0 = 0 ;
21842 PyObject * obj1 = 0 ;
21843 char *kwnames[] = {
21844 (char *) "self",(char *) "tz", NULL
21845 };
21846
21847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21849 if (SWIG_arg_fail(1)) SWIG_fail;
21850 if (obj1) {
21851 {
21852 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21853 temp2 = true;
21854 }
21855 }
21856 {
21857 PyThreadState* __tstate = wxPyBeginAllowThreads();
21858 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21859
21860 wxPyEndAllowThreads(__tstate);
21861 if (PyErr_Occurred()) SWIG_fail;
21862 }
21863 {
21864 resultobj = SWIG_From_int((int)(result));
21865 }
21866 {
21867 if (temp2) delete arg2;
21868 }
21869 return resultobj;
21870 fail:
21871 {
21872 if (temp2) delete arg2;
21873 }
21874 return NULL;
21875 }
21876
21877
21878 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj;
21880 wxDateTime *arg1 = (wxDateTime *) 0 ;
21881 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21882 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21883 int result;
21884 bool temp2 = false ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "self",(char *) "tz", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21893 if (SWIG_arg_fail(1)) SWIG_fail;
21894 if (obj1) {
21895 {
21896 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21897 temp2 = true;
21898 }
21899 }
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = SWIG_From_int((int)(result));
21909 }
21910 {
21911 if (temp2) delete arg2;
21912 }
21913 return resultobj;
21914 fail:
21915 {
21916 if (temp2) delete arg2;
21917 }
21918 return NULL;
21919 }
21920
21921
21922 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21923 PyObject *resultobj;
21924 wxDateTime *arg1 = (wxDateTime *) 0 ;
21925 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21926 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21927 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21928 int result;
21929 bool temp3 = false ;
21930 PyObject * obj0 = 0 ;
21931 PyObject * obj1 = 0 ;
21932 PyObject * obj2 = 0 ;
21933 char *kwnames[] = {
21934 (char *) "self",(char *) "flags",(char *) "tz", NULL
21935 };
21936
21937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21939 if (SWIG_arg_fail(1)) SWIG_fail;
21940 if (obj1) {
21941 {
21942 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21943 if (SWIG_arg_fail(2)) SWIG_fail;
21944 }
21945 }
21946 if (obj2) {
21947 {
21948 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21949 temp3 = true;
21950 }
21951 }
21952 {
21953 PyThreadState* __tstate = wxPyBeginAllowThreads();
21954 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21955
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 {
21960 resultobj = SWIG_From_int((int)(result));
21961 }
21962 {
21963 if (temp3) delete arg3;
21964 }
21965 return resultobj;
21966 fail:
21967 {
21968 if (temp3) delete arg3;
21969 }
21970 return NULL;
21971 }
21972
21973
21974 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21975 PyObject *resultobj;
21976 wxDateTime *arg1 = (wxDateTime *) 0 ;
21977 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21978 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21979 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21980 int result;
21981 bool temp3 = false ;
21982 PyObject * obj0 = 0 ;
21983 PyObject * obj1 = 0 ;
21984 PyObject * obj2 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "self",(char *) "flags",(char *) "tz", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 if (obj1) {
21993 {
21994 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21995 if (SWIG_arg_fail(2)) SWIG_fail;
21996 }
21997 }
21998 if (obj2) {
21999 {
22000 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
22001 temp3 = true;
22002 }
22003 }
22004 {
22005 PyThreadState* __tstate = wxPyBeginAllowThreads();
22006 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
22007
22008 wxPyEndAllowThreads(__tstate);
22009 if (PyErr_Occurred()) SWIG_fail;
22010 }
22011 {
22012 resultobj = SWIG_From_int((int)(result));
22013 }
22014 {
22015 if (temp3) delete arg3;
22016 }
22017 return resultobj;
22018 fail:
22019 {
22020 if (temp3) delete arg3;
22021 }
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxDateTime *arg1 = (wxDateTime *) 0 ;
22029 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
22030 bool result;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 char *kwnames[] = {
22034 (char *) "self",(char *) "country", NULL
22035 };
22036
22037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22039 if (SWIG_arg_fail(1)) SWIG_fail;
22040 if (obj1) {
22041 {
22042 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22043 if (SWIG_arg_fail(2)) SWIG_fail;
22044 }
22045 }
22046 {
22047 PyThreadState* __tstate = wxPyBeginAllowThreads();
22048 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22049
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22063 PyObject *resultobj;
22064 wxDateTime *arg1 = (wxDateTime *) 0 ;
22065 wxDateTime *arg2 = 0 ;
22066 bool result;
22067 PyObject * obj0 = 0 ;
22068 PyObject * obj1 = 0 ;
22069 char *kwnames[] = {
22070 (char *) "self",(char *) "datetime", NULL
22071 };
22072
22073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
22074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22075 if (SWIG_arg_fail(1)) SWIG_fail;
22076 {
22077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22078 if (SWIG_arg_fail(2)) SWIG_fail;
22079 if (arg2 == NULL) {
22080 SWIG_null_ref("wxDateTime");
22081 }
22082 if (SWIG_arg_fail(2)) SWIG_fail;
22083 }
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22087
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 {
22092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22093 }
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22101 PyObject *resultobj;
22102 wxDateTime *arg1 = (wxDateTime *) 0 ;
22103 wxDateTime *arg2 = 0 ;
22104 bool result;
22105 PyObject * obj0 = 0 ;
22106 PyObject * obj1 = 0 ;
22107 char *kwnames[] = {
22108 (char *) "self",(char *) "datetime", NULL
22109 };
22110
22111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22113 if (SWIG_arg_fail(1)) SWIG_fail;
22114 {
22115 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22116 if (SWIG_arg_fail(2)) SWIG_fail;
22117 if (arg2 == NULL) {
22118 SWIG_null_ref("wxDateTime");
22119 }
22120 if (SWIG_arg_fail(2)) SWIG_fail;
22121 }
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22125
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 {
22130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxDateTime *arg1 = (wxDateTime *) 0 ;
22141 wxDateTime *arg2 = 0 ;
22142 bool result;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145 char *kwnames[] = {
22146 (char *) "self",(char *) "datetime", NULL
22147 };
22148
22149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(1)) SWIG_fail;
22152 {
22153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 if (arg2 == NULL) {
22156 SWIG_null_ref("wxDateTime");
22157 }
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 }
22160 {
22161 PyThreadState* __tstate = wxPyBeginAllowThreads();
22162 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22163
22164 wxPyEndAllowThreads(__tstate);
22165 if (PyErr_Occurred()) SWIG_fail;
22166 }
22167 {
22168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22169 }
22170 return resultobj;
22171 fail:
22172 return NULL;
22173 }
22174
22175
22176 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22177 PyObject *resultobj;
22178 wxDateTime *arg1 = (wxDateTime *) 0 ;
22179 wxDateTime *arg2 = 0 ;
22180 wxDateTime *arg3 = 0 ;
22181 bool result;
22182 PyObject * obj0 = 0 ;
22183 PyObject * obj1 = 0 ;
22184 PyObject * obj2 = 0 ;
22185 char *kwnames[] = {
22186 (char *) "self",(char *) "t1",(char *) "t2", NULL
22187 };
22188
22189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22191 if (SWIG_arg_fail(1)) SWIG_fail;
22192 {
22193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(2)) SWIG_fail;
22195 if (arg2 == NULL) {
22196 SWIG_null_ref("wxDateTime");
22197 }
22198 if (SWIG_arg_fail(2)) SWIG_fail;
22199 }
22200 {
22201 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22202 if (SWIG_arg_fail(3)) SWIG_fail;
22203 if (arg3 == NULL) {
22204 SWIG_null_ref("wxDateTime");
22205 }
22206 if (SWIG_arg_fail(3)) SWIG_fail;
22207 }
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22211
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 {
22216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22217 }
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22225 PyObject *resultobj;
22226 wxDateTime *arg1 = (wxDateTime *) 0 ;
22227 wxDateTime *arg2 = 0 ;
22228 wxDateTime *arg3 = 0 ;
22229 bool result;
22230 PyObject * obj0 = 0 ;
22231 PyObject * obj1 = 0 ;
22232 PyObject * obj2 = 0 ;
22233 char *kwnames[] = {
22234 (char *) "self",(char *) "t1",(char *) "t2", NULL
22235 };
22236
22237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22239 if (SWIG_arg_fail(1)) SWIG_fail;
22240 {
22241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(2)) SWIG_fail;
22243 if (arg2 == NULL) {
22244 SWIG_null_ref("wxDateTime");
22245 }
22246 if (SWIG_arg_fail(2)) SWIG_fail;
22247 }
22248 {
22249 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22250 if (SWIG_arg_fail(3)) SWIG_fail;
22251 if (arg3 == NULL) {
22252 SWIG_null_ref("wxDateTime");
22253 }
22254 if (SWIG_arg_fail(3)) SWIG_fail;
22255 }
22256 {
22257 PyThreadState* __tstate = wxPyBeginAllowThreads();
22258 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22259
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 {
22264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22265 }
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22273 PyObject *resultobj;
22274 wxDateTime *arg1 = (wxDateTime *) 0 ;
22275 wxDateTime *arg2 = 0 ;
22276 bool result;
22277 PyObject * obj0 = 0 ;
22278 PyObject * obj1 = 0 ;
22279 char *kwnames[] = {
22280 (char *) "self",(char *) "dt", NULL
22281 };
22282
22283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22285 if (SWIG_arg_fail(1)) SWIG_fail;
22286 {
22287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(2)) SWIG_fail;
22289 if (arg2 == NULL) {
22290 SWIG_null_ref("wxDateTime");
22291 }
22292 if (SWIG_arg_fail(2)) SWIG_fail;
22293 }
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22297
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 {
22302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22303 }
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22311 PyObject *resultobj;
22312 wxDateTime *arg1 = (wxDateTime *) 0 ;
22313 wxDateTime *arg2 = 0 ;
22314 bool result;
22315 PyObject * obj0 = 0 ;
22316 PyObject * obj1 = 0 ;
22317 char *kwnames[] = {
22318 (char *) "self",(char *) "dt", NULL
22319 };
22320
22321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22323 if (SWIG_arg_fail(1)) SWIG_fail;
22324 {
22325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22326 if (SWIG_arg_fail(2)) SWIG_fail;
22327 if (arg2 == NULL) {
22328 SWIG_null_ref("wxDateTime");
22329 }
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 }
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22335
22336 wxPyEndAllowThreads(__tstate);
22337 if (PyErr_Occurred()) SWIG_fail;
22338 }
22339 {
22340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22341 }
22342 return resultobj;
22343 fail:
22344 return NULL;
22345 }
22346
22347
22348 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22349 PyObject *resultobj;
22350 wxDateTime *arg1 = (wxDateTime *) 0 ;
22351 wxDateTime *arg2 = 0 ;
22352 wxTimeSpan *arg3 = 0 ;
22353 bool result;
22354 PyObject * obj0 = 0 ;
22355 PyObject * obj1 = 0 ;
22356 PyObject * obj2 = 0 ;
22357 char *kwnames[] = {
22358 (char *) "self",(char *) "dt",(char *) "ts", NULL
22359 };
22360
22361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22363 if (SWIG_arg_fail(1)) SWIG_fail;
22364 {
22365 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(2)) SWIG_fail;
22367 if (arg2 == NULL) {
22368 SWIG_null_ref("wxDateTime");
22369 }
22370 if (SWIG_arg_fail(2)) SWIG_fail;
22371 }
22372 {
22373 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22374 if (SWIG_arg_fail(3)) SWIG_fail;
22375 if (arg3 == NULL) {
22376 SWIG_null_ref("wxTimeSpan");
22377 }
22378 if (SWIG_arg_fail(3)) SWIG_fail;
22379 }
22380 {
22381 PyThreadState* __tstate = wxPyBeginAllowThreads();
22382 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22383
22384 wxPyEndAllowThreads(__tstate);
22385 if (PyErr_Occurred()) SWIG_fail;
22386 }
22387 {
22388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22389 }
22390 return resultobj;
22391 fail:
22392 return NULL;
22393 }
22394
22395
22396 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22397 PyObject *resultobj;
22398 wxDateTime *arg1 = (wxDateTime *) 0 ;
22399 wxTimeSpan *arg2 = 0 ;
22400 wxDateTime *result;
22401 PyObject * obj0 = 0 ;
22402 PyObject * obj1 = 0 ;
22403 char *kwnames[] = {
22404 (char *) "self",(char *) "diff", NULL
22405 };
22406
22407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22409 if (SWIG_arg_fail(1)) SWIG_fail;
22410 {
22411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22412 if (SWIG_arg_fail(2)) SWIG_fail;
22413 if (arg2 == NULL) {
22414 SWIG_null_ref("wxTimeSpan");
22415 }
22416 if (SWIG_arg_fail(2)) SWIG_fail;
22417 }
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 {
22421 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22422 result = (wxDateTime *) &_result_ref;
22423 }
22424
22425 wxPyEndAllowThreads(__tstate);
22426 if (PyErr_Occurred()) SWIG_fail;
22427 }
22428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22429 return resultobj;
22430 fail:
22431 return NULL;
22432 }
22433
22434
22435 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22436 PyObject *resultobj;
22437 wxDateTime *arg1 = (wxDateTime *) 0 ;
22438 wxDateSpan *arg2 = 0 ;
22439 wxDateTime *result;
22440 PyObject * obj0 = 0 ;
22441 PyObject * obj1 = 0 ;
22442 char *kwnames[] = {
22443 (char *) "self",(char *) "diff", NULL
22444 };
22445
22446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22448 if (SWIG_arg_fail(1)) SWIG_fail;
22449 {
22450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22451 if (SWIG_arg_fail(2)) SWIG_fail;
22452 if (arg2 == NULL) {
22453 SWIG_null_ref("wxDateSpan");
22454 }
22455 if (SWIG_arg_fail(2)) SWIG_fail;
22456 }
22457 {
22458 PyThreadState* __tstate = wxPyBeginAllowThreads();
22459 {
22460 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22461 result = (wxDateTime *) &_result_ref;
22462 }
22463
22464 wxPyEndAllowThreads(__tstate);
22465 if (PyErr_Occurred()) SWIG_fail;
22466 }
22467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj;
22476 wxDateTime *arg1 = (wxDateTime *) 0 ;
22477 wxTimeSpan *arg2 = 0 ;
22478 wxDateTime *result;
22479 PyObject * obj0 = 0 ;
22480 PyObject * obj1 = 0 ;
22481 char *kwnames[] = {
22482 (char *) "self",(char *) "diff", NULL
22483 };
22484
22485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22487 if (SWIG_arg_fail(1)) SWIG_fail;
22488 {
22489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22490 if (SWIG_arg_fail(2)) SWIG_fail;
22491 if (arg2 == NULL) {
22492 SWIG_null_ref("wxTimeSpan");
22493 }
22494 if (SWIG_arg_fail(2)) SWIG_fail;
22495 }
22496 {
22497 PyThreadState* __tstate = wxPyBeginAllowThreads();
22498 {
22499 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22500 result = (wxDateTime *) &_result_ref;
22501 }
22502
22503 wxPyEndAllowThreads(__tstate);
22504 if (PyErr_Occurred()) SWIG_fail;
22505 }
22506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22507 return resultobj;
22508 fail:
22509 return NULL;
22510 }
22511
22512
22513 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22514 PyObject *resultobj;
22515 wxDateTime *arg1 = (wxDateTime *) 0 ;
22516 wxDateSpan *arg2 = 0 ;
22517 wxDateTime *result;
22518 PyObject * obj0 = 0 ;
22519 PyObject * obj1 = 0 ;
22520 char *kwnames[] = {
22521 (char *) "self",(char *) "diff", NULL
22522 };
22523
22524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22526 if (SWIG_arg_fail(1)) SWIG_fail;
22527 {
22528 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(2)) SWIG_fail;
22530 if (arg2 == NULL) {
22531 SWIG_null_ref("wxDateSpan");
22532 }
22533 if (SWIG_arg_fail(2)) SWIG_fail;
22534 }
22535 {
22536 PyThreadState* __tstate = wxPyBeginAllowThreads();
22537 {
22538 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22539 result = (wxDateTime *) &_result_ref;
22540 }
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22553 PyObject *resultobj;
22554 wxDateTime *arg1 = (wxDateTime *) 0 ;
22555 wxDateTime *arg2 = 0 ;
22556 wxTimeSpan result;
22557 PyObject * obj0 = 0 ;
22558 PyObject * obj1 = 0 ;
22559 char *kwnames[] = {
22560 (char *) "self",(char *) "dt", NULL
22561 };
22562
22563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22565 if (SWIG_arg_fail(1)) SWIG_fail;
22566 {
22567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22568 if (SWIG_arg_fail(2)) SWIG_fail;
22569 if (arg2 == NULL) {
22570 SWIG_null_ref("wxDateTime");
22571 }
22572 if (SWIG_arg_fail(2)) SWIG_fail;
22573 }
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22577
22578 wxPyEndAllowThreads(__tstate);
22579 if (PyErr_Occurred()) SWIG_fail;
22580 }
22581 {
22582 wxTimeSpan * resultptr;
22583 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22584 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22585 }
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22593 PyObject *resultobj;
22594 wxDateTime *arg1 = (wxDateTime *) 0 ;
22595 wxTimeSpan *arg2 = 0 ;
22596 wxDateTime *result;
22597 PyObject * obj0 = 0 ;
22598 PyObject * obj1 = 0 ;
22599
22600 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22602 if (SWIG_arg_fail(1)) SWIG_fail;
22603 {
22604 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 if (arg2 == NULL) {
22607 SWIG_null_ref("wxTimeSpan");
22608 }
22609 if (SWIG_arg_fail(2)) SWIG_fail;
22610 }
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 {
22614 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22615 result = (wxDateTime *) &_result_ref;
22616 }
22617
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22629 PyObject *resultobj;
22630 wxDateTime *arg1 = (wxDateTime *) 0 ;
22631 wxDateSpan *arg2 = 0 ;
22632 wxDateTime *result;
22633 PyObject * obj0 = 0 ;
22634 PyObject * obj1 = 0 ;
22635
22636 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22638 if (SWIG_arg_fail(1)) SWIG_fail;
22639 {
22640 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22641 if (SWIG_arg_fail(2)) SWIG_fail;
22642 if (arg2 == NULL) {
22643 SWIG_null_ref("wxDateSpan");
22644 }
22645 if (SWIG_arg_fail(2)) SWIG_fail;
22646 }
22647 {
22648 PyThreadState* __tstate = wxPyBeginAllowThreads();
22649 {
22650 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22651 result = (wxDateTime *) &_result_ref;
22652 }
22653
22654 wxPyEndAllowThreads(__tstate);
22655 if (PyErr_Occurred()) SWIG_fail;
22656 }
22657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22658 return resultobj;
22659 fail:
22660 return NULL;
22661 }
22662
22663
22664 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22665 int argc;
22666 PyObject *argv[3];
22667 int ii;
22668
22669 argc = PyObject_Length(args);
22670 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22671 argv[ii] = PyTuple_GetItem(args,ii);
22672 }
22673 if (argc == 2) {
22674 int _v;
22675 {
22676 void *ptr;
22677 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22678 _v = 0;
22679 PyErr_Clear();
22680 } else {
22681 _v = 1;
22682 }
22683 }
22684 if (_v) {
22685 {
22686 void *ptr = 0;
22687 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22688 _v = 0;
22689 PyErr_Clear();
22690 } else {
22691 _v = (ptr != 0);
22692 }
22693 }
22694 if (_v) {
22695 return _wrap_DateTime___iadd____SWIG_0(self,args);
22696 }
22697 }
22698 }
22699 if (argc == 2) {
22700 int _v;
22701 {
22702 void *ptr;
22703 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22704 _v = 0;
22705 PyErr_Clear();
22706 } else {
22707 _v = 1;
22708 }
22709 }
22710 if (_v) {
22711 {
22712 void *ptr = 0;
22713 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22714 _v = 0;
22715 PyErr_Clear();
22716 } else {
22717 _v = (ptr != 0);
22718 }
22719 }
22720 if (_v) {
22721 return _wrap_DateTime___iadd____SWIG_1(self,args);
22722 }
22723 }
22724 }
22725
22726 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22727 return NULL;
22728 }
22729
22730
22731 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22732 PyObject *resultobj;
22733 wxDateTime *arg1 = (wxDateTime *) 0 ;
22734 wxTimeSpan *arg2 = 0 ;
22735 wxDateTime *result;
22736 PyObject * obj0 = 0 ;
22737 PyObject * obj1 = 0 ;
22738
22739 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22741 if (SWIG_arg_fail(1)) SWIG_fail;
22742 {
22743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(2)) SWIG_fail;
22745 if (arg2 == NULL) {
22746 SWIG_null_ref("wxTimeSpan");
22747 }
22748 if (SWIG_arg_fail(2)) SWIG_fail;
22749 }
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 {
22753 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22754 result = (wxDateTime *) &_result_ref;
22755 }
22756
22757 wxPyEndAllowThreads(__tstate);
22758 if (PyErr_Occurred()) SWIG_fail;
22759 }
22760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22761 return resultobj;
22762 fail:
22763 return NULL;
22764 }
22765
22766
22767 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22768 PyObject *resultobj;
22769 wxDateTime *arg1 = (wxDateTime *) 0 ;
22770 wxDateSpan *arg2 = 0 ;
22771 wxDateTime *result;
22772 PyObject * obj0 = 0 ;
22773 PyObject * obj1 = 0 ;
22774
22775 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22777 if (SWIG_arg_fail(1)) SWIG_fail;
22778 {
22779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22780 if (SWIG_arg_fail(2)) SWIG_fail;
22781 if (arg2 == NULL) {
22782 SWIG_null_ref("wxDateSpan");
22783 }
22784 if (SWIG_arg_fail(2)) SWIG_fail;
22785 }
22786 {
22787 PyThreadState* __tstate = wxPyBeginAllowThreads();
22788 {
22789 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22790 result = (wxDateTime *) &_result_ref;
22791 }
22792
22793 wxPyEndAllowThreads(__tstate);
22794 if (PyErr_Occurred()) SWIG_fail;
22795 }
22796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22797 return resultobj;
22798 fail:
22799 return NULL;
22800 }
22801
22802
22803 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22804 int argc;
22805 PyObject *argv[3];
22806 int ii;
22807
22808 argc = PyObject_Length(args);
22809 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22810 argv[ii] = PyTuple_GetItem(args,ii);
22811 }
22812 if (argc == 2) {
22813 int _v;
22814 {
22815 void *ptr;
22816 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22817 _v = 0;
22818 PyErr_Clear();
22819 } else {
22820 _v = 1;
22821 }
22822 }
22823 if (_v) {
22824 {
22825 void *ptr = 0;
22826 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22827 _v = 0;
22828 PyErr_Clear();
22829 } else {
22830 _v = (ptr != 0);
22831 }
22832 }
22833 if (_v) {
22834 return _wrap_DateTime___isub____SWIG_0(self,args);
22835 }
22836 }
22837 }
22838 if (argc == 2) {
22839 int _v;
22840 {
22841 void *ptr;
22842 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22843 _v = 0;
22844 PyErr_Clear();
22845 } else {
22846 _v = 1;
22847 }
22848 }
22849 if (_v) {
22850 {
22851 void *ptr = 0;
22852 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22853 _v = 0;
22854 PyErr_Clear();
22855 } else {
22856 _v = (ptr != 0);
22857 }
22858 }
22859 if (_v) {
22860 return _wrap_DateTime___isub____SWIG_1(self,args);
22861 }
22862 }
22863 }
22864
22865 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22866 return NULL;
22867 }
22868
22869
22870 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22871 PyObject *resultobj;
22872 wxDateTime *arg1 = (wxDateTime *) 0 ;
22873 wxTimeSpan *arg2 = 0 ;
22874 wxDateTime result;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877
22878 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(1)) SWIG_fail;
22881 {
22882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(2)) SWIG_fail;
22884 if (arg2 == NULL) {
22885 SWIG_null_ref("wxTimeSpan");
22886 }
22887 if (SWIG_arg_fail(2)) SWIG_fail;
22888 }
22889 {
22890 PyThreadState* __tstate = wxPyBeginAllowThreads();
22891 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22892
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 {
22897 wxDateTime * resultptr;
22898 resultptr = new wxDateTime((wxDateTime &)(result));
22899 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22900 }
22901 return resultobj;
22902 fail:
22903 return NULL;
22904 }
22905
22906
22907 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22908 PyObject *resultobj;
22909 wxDateTime *arg1 = (wxDateTime *) 0 ;
22910 wxDateSpan *arg2 = 0 ;
22911 wxDateTime result;
22912 PyObject * obj0 = 0 ;
22913 PyObject * obj1 = 0 ;
22914
22915 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 {
22919 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22920 if (SWIG_arg_fail(2)) SWIG_fail;
22921 if (arg2 == NULL) {
22922 SWIG_null_ref("wxDateSpan");
22923 }
22924 if (SWIG_arg_fail(2)) SWIG_fail;
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 {
22934 wxDateTime * resultptr;
22935 resultptr = new wxDateTime((wxDateTime &)(result));
22936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22937 }
22938 return resultobj;
22939 fail:
22940 return NULL;
22941 }
22942
22943
22944 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22945 int argc;
22946 PyObject *argv[3];
22947 int ii;
22948
22949 argc = PyObject_Length(args);
22950 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22951 argv[ii] = PyTuple_GetItem(args,ii);
22952 }
22953 if (argc == 2) {
22954 int _v;
22955 {
22956 void *ptr;
22957 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22958 _v = 0;
22959 PyErr_Clear();
22960 } else {
22961 _v = 1;
22962 }
22963 }
22964 if (_v) {
22965 {
22966 void *ptr = 0;
22967 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22968 _v = 0;
22969 PyErr_Clear();
22970 } else {
22971 _v = (ptr != 0);
22972 }
22973 }
22974 if (_v) {
22975 return _wrap_DateTime___add____SWIG_0(self,args);
22976 }
22977 }
22978 }
22979 if (argc == 2) {
22980 int _v;
22981 {
22982 void *ptr;
22983 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22984 _v = 0;
22985 PyErr_Clear();
22986 } else {
22987 _v = 1;
22988 }
22989 }
22990 if (_v) {
22991 {
22992 void *ptr = 0;
22993 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22994 _v = 0;
22995 PyErr_Clear();
22996 } else {
22997 _v = (ptr != 0);
22998 }
22999 }
23000 if (_v) {
23001 return _wrap_DateTime___add____SWIG_1(self,args);
23002 }
23003 }
23004 }
23005
23006 Py_INCREF(Py_NotImplemented);
23007 return Py_NotImplemented;
23008 }
23009
23010
23011 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
23012 PyObject *resultobj;
23013 wxDateTime *arg1 = (wxDateTime *) 0 ;
23014 wxDateTime *arg2 = 0 ;
23015 wxTimeSpan result;
23016 PyObject * obj0 = 0 ;
23017 PyObject * obj1 = 0 ;
23018
23019 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23021 if (SWIG_arg_fail(1)) SWIG_fail;
23022 {
23023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23024 if (SWIG_arg_fail(2)) SWIG_fail;
23025 if (arg2 == NULL) {
23026 SWIG_null_ref("wxDateTime");
23027 }
23028 if (SWIG_arg_fail(2)) SWIG_fail;
23029 }
23030 {
23031 PyThreadState* __tstate = wxPyBeginAllowThreads();
23032 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
23033
23034 wxPyEndAllowThreads(__tstate);
23035 if (PyErr_Occurred()) SWIG_fail;
23036 }
23037 {
23038 wxTimeSpan * resultptr;
23039 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23041 }
23042 return resultobj;
23043 fail:
23044 return NULL;
23045 }
23046
23047
23048 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23049 PyObject *resultobj;
23050 wxDateTime *arg1 = (wxDateTime *) 0 ;
23051 wxTimeSpan *arg2 = 0 ;
23052 wxDateTime result;
23053 PyObject * obj0 = 0 ;
23054 PyObject * obj1 = 0 ;
23055
23056 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 {
23060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23061 if (SWIG_arg_fail(2)) SWIG_fail;
23062 if (arg2 == NULL) {
23063 SWIG_null_ref("wxTimeSpan");
23064 }
23065 if (SWIG_arg_fail(2)) SWIG_fail;
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 {
23075 wxDateTime * resultptr;
23076 resultptr = new wxDateTime((wxDateTime &)(result));
23077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23078 }
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23086 PyObject *resultobj;
23087 wxDateTime *arg1 = (wxDateTime *) 0 ;
23088 wxDateSpan *arg2 = 0 ;
23089 wxDateTime result;
23090 PyObject * obj0 = 0 ;
23091 PyObject * obj1 = 0 ;
23092
23093 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23095 if (SWIG_arg_fail(1)) SWIG_fail;
23096 {
23097 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23098 if (SWIG_arg_fail(2)) SWIG_fail;
23099 if (arg2 == NULL) {
23100 SWIG_null_ref("wxDateSpan");
23101 }
23102 if (SWIG_arg_fail(2)) SWIG_fail;
23103 }
23104 {
23105 PyThreadState* __tstate = wxPyBeginAllowThreads();
23106 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23107
23108 wxPyEndAllowThreads(__tstate);
23109 if (PyErr_Occurred()) SWIG_fail;
23110 }
23111 {
23112 wxDateTime * resultptr;
23113 resultptr = new wxDateTime((wxDateTime &)(result));
23114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23115 }
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23123 int argc;
23124 PyObject *argv[3];
23125 int ii;
23126
23127 argc = PyObject_Length(args);
23128 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23129 argv[ii] = PyTuple_GetItem(args,ii);
23130 }
23131 if (argc == 2) {
23132 int _v;
23133 {
23134 void *ptr;
23135 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23136 _v = 0;
23137 PyErr_Clear();
23138 } else {
23139 _v = 1;
23140 }
23141 }
23142 if (_v) {
23143 {
23144 void *ptr = 0;
23145 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23146 _v = 0;
23147 PyErr_Clear();
23148 } else {
23149 _v = (ptr != 0);
23150 }
23151 }
23152 if (_v) {
23153 return _wrap_DateTime___sub____SWIG_0(self,args);
23154 }
23155 }
23156 }
23157 if (argc == 2) {
23158 int _v;
23159 {
23160 void *ptr;
23161 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23162 _v = 0;
23163 PyErr_Clear();
23164 } else {
23165 _v = 1;
23166 }
23167 }
23168 if (_v) {
23169 {
23170 void *ptr = 0;
23171 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23172 _v = 0;
23173 PyErr_Clear();
23174 } else {
23175 _v = (ptr != 0);
23176 }
23177 }
23178 if (_v) {
23179 return _wrap_DateTime___sub____SWIG_1(self,args);
23180 }
23181 }
23182 }
23183 if (argc == 2) {
23184 int _v;
23185 {
23186 void *ptr;
23187 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23188 _v = 0;
23189 PyErr_Clear();
23190 } else {
23191 _v = 1;
23192 }
23193 }
23194 if (_v) {
23195 {
23196 void *ptr = 0;
23197 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23198 _v = 0;
23199 PyErr_Clear();
23200 } else {
23201 _v = (ptr != 0);
23202 }
23203 }
23204 if (_v) {
23205 return _wrap_DateTime___sub____SWIG_2(self,args);
23206 }
23207 }
23208 }
23209
23210 Py_INCREF(Py_NotImplemented);
23211 return Py_NotImplemented;
23212 }
23213
23214
23215 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23216 PyObject *resultobj;
23217 wxDateTime *arg1 = (wxDateTime *) 0 ;
23218 wxDateTime *arg2 = (wxDateTime *) 0 ;
23219 bool result;
23220 PyObject * obj0 = 0 ;
23221 PyObject * obj1 = 0 ;
23222 char *kwnames[] = {
23223 (char *) "self",(char *) "other", NULL
23224 };
23225
23226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23228 if (SWIG_arg_fail(1)) SWIG_fail;
23229 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23230 if (SWIG_arg_fail(2)) SWIG_fail;
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23234
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 {
23239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23240 }
23241 return resultobj;
23242 fail:
23243 return NULL;
23244 }
23245
23246
23247 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23248 PyObject *resultobj;
23249 wxDateTime *arg1 = (wxDateTime *) 0 ;
23250 wxDateTime *arg2 = (wxDateTime *) 0 ;
23251 bool result;
23252 PyObject * obj0 = 0 ;
23253 PyObject * obj1 = 0 ;
23254 char *kwnames[] = {
23255 (char *) "self",(char *) "other", NULL
23256 };
23257
23258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23260 if (SWIG_arg_fail(1)) SWIG_fail;
23261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23262 if (SWIG_arg_fail(2)) SWIG_fail;
23263 {
23264 PyThreadState* __tstate = wxPyBeginAllowThreads();
23265 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23266
23267 wxPyEndAllowThreads(__tstate);
23268 if (PyErr_Occurred()) SWIG_fail;
23269 }
23270 {
23271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23272 }
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23280 PyObject *resultobj;
23281 wxDateTime *arg1 = (wxDateTime *) 0 ;
23282 wxDateTime *arg2 = (wxDateTime *) 0 ;
23283 bool result;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 char *kwnames[] = {
23287 (char *) "self",(char *) "other", NULL
23288 };
23289
23290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23292 if (SWIG_arg_fail(1)) SWIG_fail;
23293 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23294 if (SWIG_arg_fail(2)) SWIG_fail;
23295 {
23296 PyThreadState* __tstate = wxPyBeginAllowThreads();
23297 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23298
23299 wxPyEndAllowThreads(__tstate);
23300 if (PyErr_Occurred()) SWIG_fail;
23301 }
23302 {
23303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23304 }
23305 return resultobj;
23306 fail:
23307 return NULL;
23308 }
23309
23310
23311 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23312 PyObject *resultobj;
23313 wxDateTime *arg1 = (wxDateTime *) 0 ;
23314 wxDateTime *arg2 = (wxDateTime *) 0 ;
23315 bool result;
23316 PyObject * obj0 = 0 ;
23317 PyObject * obj1 = 0 ;
23318 char *kwnames[] = {
23319 (char *) "self",(char *) "other", NULL
23320 };
23321
23322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23324 if (SWIG_arg_fail(1)) SWIG_fail;
23325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23326 if (SWIG_arg_fail(2)) SWIG_fail;
23327 {
23328 PyThreadState* __tstate = wxPyBeginAllowThreads();
23329 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23330
23331 wxPyEndAllowThreads(__tstate);
23332 if (PyErr_Occurred()) SWIG_fail;
23333 }
23334 {
23335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23336 }
23337 return resultobj;
23338 fail:
23339 return NULL;
23340 }
23341
23342
23343 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj;
23345 wxDateTime *arg1 = (wxDateTime *) 0 ;
23346 wxDateTime *arg2 = (wxDateTime *) 0 ;
23347 bool result;
23348 PyObject * obj0 = 0 ;
23349 PyObject * obj1 = 0 ;
23350 char *kwnames[] = {
23351 (char *) "self",(char *) "other", NULL
23352 };
23353
23354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23356 if (SWIG_arg_fail(1)) SWIG_fail;
23357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23358 if (SWIG_arg_fail(2)) SWIG_fail;
23359 {
23360 PyThreadState* __tstate = wxPyBeginAllowThreads();
23361 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23362
23363 wxPyEndAllowThreads(__tstate);
23364 if (PyErr_Occurred()) SWIG_fail;
23365 }
23366 {
23367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23368 }
23369 return resultobj;
23370 fail:
23371 return NULL;
23372 }
23373
23374
23375 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23376 PyObject *resultobj;
23377 wxDateTime *arg1 = (wxDateTime *) 0 ;
23378 wxDateTime *arg2 = (wxDateTime *) 0 ;
23379 bool result;
23380 PyObject * obj0 = 0 ;
23381 PyObject * obj1 = 0 ;
23382 char *kwnames[] = {
23383 (char *) "self",(char *) "other", NULL
23384 };
23385
23386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23388 if (SWIG_arg_fail(1)) SWIG_fail;
23389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23390 if (SWIG_arg_fail(2)) SWIG_fail;
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23394
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 {
23399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23400 }
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23408 PyObject *resultobj;
23409 wxDateTime *arg1 = (wxDateTime *) 0 ;
23410 wxString *arg2 = 0 ;
23411 int result;
23412 bool temp2 = false ;
23413 PyObject * obj0 = 0 ;
23414 PyObject * obj1 = 0 ;
23415 char *kwnames[] = {
23416 (char *) "self",(char *) "date", NULL
23417 };
23418
23419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23421 if (SWIG_arg_fail(1)) SWIG_fail;
23422 {
23423 arg2 = wxString_in_helper(obj1);
23424 if (arg2 == NULL) SWIG_fail;
23425 temp2 = true;
23426 }
23427 {
23428 PyThreadState* __tstate = wxPyBeginAllowThreads();
23429 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23430
23431 wxPyEndAllowThreads(__tstate);
23432 if (PyErr_Occurred()) SWIG_fail;
23433 }
23434 {
23435 resultobj = SWIG_From_int((int)(result));
23436 }
23437 {
23438 if (temp2)
23439 delete arg2;
23440 }
23441 return resultobj;
23442 fail:
23443 {
23444 if (temp2)
23445 delete arg2;
23446 }
23447 return NULL;
23448 }
23449
23450
23451 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23452 PyObject *resultobj;
23453 wxDateTime *arg1 = (wxDateTime *) 0 ;
23454 wxString *arg2 = 0 ;
23455 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23456 wxString *arg3 = (wxString *) &arg3_defvalue ;
23457 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23458 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23459 int result;
23460 bool temp2 = false ;
23461 bool temp3 = false ;
23462 PyObject * obj0 = 0 ;
23463 PyObject * obj1 = 0 ;
23464 PyObject * obj2 = 0 ;
23465 PyObject * obj3 = 0 ;
23466 char *kwnames[] = {
23467 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23468 };
23469
23470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23472 if (SWIG_arg_fail(1)) SWIG_fail;
23473 {
23474 arg2 = wxString_in_helper(obj1);
23475 if (arg2 == NULL) SWIG_fail;
23476 temp2 = true;
23477 }
23478 if (obj2) {
23479 {
23480 arg3 = wxString_in_helper(obj2);
23481 if (arg3 == NULL) SWIG_fail;
23482 temp3 = true;
23483 }
23484 }
23485 if (obj3) {
23486 {
23487 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23488 if (SWIG_arg_fail(4)) SWIG_fail;
23489 if (arg4 == NULL) {
23490 SWIG_null_ref("wxDateTime");
23491 }
23492 if (SWIG_arg_fail(4)) SWIG_fail;
23493 }
23494 }
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23498
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 {
23503 resultobj = SWIG_From_int((int)(result));
23504 }
23505 {
23506 if (temp2)
23507 delete arg2;
23508 }
23509 {
23510 if (temp3)
23511 delete arg3;
23512 }
23513 return resultobj;
23514 fail:
23515 {
23516 if (temp2)
23517 delete arg2;
23518 }
23519 {
23520 if (temp3)
23521 delete arg3;
23522 }
23523 return NULL;
23524 }
23525
23526
23527 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj;
23529 wxDateTime *arg1 = (wxDateTime *) 0 ;
23530 wxString *arg2 = 0 ;
23531 int result;
23532 bool temp2 = false ;
23533 PyObject * obj0 = 0 ;
23534 PyObject * obj1 = 0 ;
23535 char *kwnames[] = {
23536 (char *) "self",(char *) "datetime", NULL
23537 };
23538
23539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23541 if (SWIG_arg_fail(1)) SWIG_fail;
23542 {
23543 arg2 = wxString_in_helper(obj1);
23544 if (arg2 == NULL) SWIG_fail;
23545 temp2 = true;
23546 }
23547 {
23548 PyThreadState* __tstate = wxPyBeginAllowThreads();
23549 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23550
23551 wxPyEndAllowThreads(__tstate);
23552 if (PyErr_Occurred()) SWIG_fail;
23553 }
23554 {
23555 resultobj = SWIG_From_int((int)(result));
23556 }
23557 {
23558 if (temp2)
23559 delete arg2;
23560 }
23561 return resultobj;
23562 fail:
23563 {
23564 if (temp2)
23565 delete arg2;
23566 }
23567 return NULL;
23568 }
23569
23570
23571 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23572 PyObject *resultobj;
23573 wxDateTime *arg1 = (wxDateTime *) 0 ;
23574 wxString *arg2 = 0 ;
23575 int result;
23576 bool temp2 = false ;
23577 PyObject * obj0 = 0 ;
23578 PyObject * obj1 = 0 ;
23579 char *kwnames[] = {
23580 (char *) "self",(char *) "date", NULL
23581 };
23582
23583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23585 if (SWIG_arg_fail(1)) SWIG_fail;
23586 {
23587 arg2 = wxString_in_helper(obj1);
23588 if (arg2 == NULL) SWIG_fail;
23589 temp2 = true;
23590 }
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = SWIG_From_int((int)(result));
23600 }
23601 {
23602 if (temp2)
23603 delete arg2;
23604 }
23605 return resultobj;
23606 fail:
23607 {
23608 if (temp2)
23609 delete arg2;
23610 }
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 wxDateTime *arg1 = (wxDateTime *) 0 ;
23618 wxString *arg2 = 0 ;
23619 int result;
23620 bool temp2 = false ;
23621 PyObject * obj0 = 0 ;
23622 PyObject * obj1 = 0 ;
23623 char *kwnames[] = {
23624 (char *) "self",(char *) "time", NULL
23625 };
23626
23627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23629 if (SWIG_arg_fail(1)) SWIG_fail;
23630 {
23631 arg2 = wxString_in_helper(obj1);
23632 if (arg2 == NULL) SWIG_fail;
23633 temp2 = true;
23634 }
23635 {
23636 PyThreadState* __tstate = wxPyBeginAllowThreads();
23637 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23638
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = SWIG_From_int((int)(result));
23644 }
23645 {
23646 if (temp2)
23647 delete arg2;
23648 }
23649 return resultobj;
23650 fail:
23651 {
23652 if (temp2)
23653 delete arg2;
23654 }
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 wxDateTime *arg1 = (wxDateTime *) 0 ;
23662 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23663 wxString *arg2 = (wxString *) &arg2_defvalue ;
23664 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23665 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23666 wxString result;
23667 bool temp2 = false ;
23668 bool temp3 = false ;
23669 PyObject * obj0 = 0 ;
23670 PyObject * obj1 = 0 ;
23671 PyObject * obj2 = 0 ;
23672 char *kwnames[] = {
23673 (char *) "self",(char *) "format",(char *) "tz", NULL
23674 };
23675
23676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23678 if (SWIG_arg_fail(1)) SWIG_fail;
23679 if (obj1) {
23680 {
23681 arg2 = wxString_in_helper(obj1);
23682 if (arg2 == NULL) SWIG_fail;
23683 temp2 = true;
23684 }
23685 }
23686 if (obj2) {
23687 {
23688 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23689 temp3 = true;
23690 }
23691 }
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23695
23696 wxPyEndAllowThreads(__tstate);
23697 if (PyErr_Occurred()) SWIG_fail;
23698 }
23699 {
23700 #if wxUSE_UNICODE
23701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23702 #else
23703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23704 #endif
23705 }
23706 {
23707 if (temp2)
23708 delete arg2;
23709 }
23710 {
23711 if (temp3) delete arg3;
23712 }
23713 return resultobj;
23714 fail:
23715 {
23716 if (temp2)
23717 delete arg2;
23718 }
23719 {
23720 if (temp3) delete arg3;
23721 }
23722 return NULL;
23723 }
23724
23725
23726 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj;
23728 wxDateTime *arg1 = (wxDateTime *) 0 ;
23729 wxString result;
23730 PyObject * obj0 = 0 ;
23731 char *kwnames[] = {
23732 (char *) "self", NULL
23733 };
23734
23735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23737 if (SWIG_arg_fail(1)) SWIG_fail;
23738 {
23739 PyThreadState* __tstate = wxPyBeginAllowThreads();
23740 result = ((wxDateTime const *)arg1)->FormatDate();
23741
23742 wxPyEndAllowThreads(__tstate);
23743 if (PyErr_Occurred()) SWIG_fail;
23744 }
23745 {
23746 #if wxUSE_UNICODE
23747 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23748 #else
23749 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23750 #endif
23751 }
23752 return resultobj;
23753 fail:
23754 return NULL;
23755 }
23756
23757
23758 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23759 PyObject *resultobj;
23760 wxDateTime *arg1 = (wxDateTime *) 0 ;
23761 wxString result;
23762 PyObject * obj0 = 0 ;
23763 char *kwnames[] = {
23764 (char *) "self", NULL
23765 };
23766
23767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23769 if (SWIG_arg_fail(1)) SWIG_fail;
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = ((wxDateTime const *)arg1)->FormatTime();
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 {
23778 #if wxUSE_UNICODE
23779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23780 #else
23781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23782 #endif
23783 }
23784 return resultobj;
23785 fail:
23786 return NULL;
23787 }
23788
23789
23790 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23791 PyObject *resultobj;
23792 wxDateTime *arg1 = (wxDateTime *) 0 ;
23793 wxString result;
23794 PyObject * obj0 = 0 ;
23795 char *kwnames[] = {
23796 (char *) "self", NULL
23797 };
23798
23799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23801 if (SWIG_arg_fail(1)) SWIG_fail;
23802 {
23803 PyThreadState* __tstate = wxPyBeginAllowThreads();
23804 result = ((wxDateTime const *)arg1)->FormatISODate();
23805
23806 wxPyEndAllowThreads(__tstate);
23807 if (PyErr_Occurred()) SWIG_fail;
23808 }
23809 {
23810 #if wxUSE_UNICODE
23811 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23812 #else
23813 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23814 #endif
23815 }
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj;
23824 wxDateTime *arg1 = (wxDateTime *) 0 ;
23825 wxString result;
23826 PyObject * obj0 = 0 ;
23827 char *kwnames[] = {
23828 (char *) "self", NULL
23829 };
23830
23831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23833 if (SWIG_arg_fail(1)) SWIG_fail;
23834 {
23835 PyThreadState* __tstate = wxPyBeginAllowThreads();
23836 result = ((wxDateTime const *)arg1)->FormatISOTime();
23837
23838 wxPyEndAllowThreads(__tstate);
23839 if (PyErr_Occurred()) SWIG_fail;
23840 }
23841 {
23842 #if wxUSE_UNICODE
23843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23844 #else
23845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23846 #endif
23847 }
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23855 PyObject *obj;
23856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23857 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23858 Py_INCREF(obj);
23859 return Py_BuildValue((char *)"");
23860 }
23861 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23862 PyObject *resultobj;
23863 long arg1 ;
23864 wxTimeSpan result;
23865 PyObject * obj0 = 0 ;
23866 char *kwnames[] = {
23867 (char *) "sec", NULL
23868 };
23869
23870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23871 {
23872 arg1 = (long)(SWIG_As_long(obj0));
23873 if (SWIG_arg_fail(1)) SWIG_fail;
23874 }
23875 {
23876 PyThreadState* __tstate = wxPyBeginAllowThreads();
23877 result = wxTimeSpan::Seconds(arg1);
23878
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 {
23883 wxTimeSpan * resultptr;
23884 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23886 }
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23894 PyObject *resultobj;
23895 wxTimeSpan result;
23896 char *kwnames[] = {
23897 NULL
23898 };
23899
23900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23901 {
23902 PyThreadState* __tstate = wxPyBeginAllowThreads();
23903 result = wxTimeSpan::Second();
23904
23905 wxPyEndAllowThreads(__tstate);
23906 if (PyErr_Occurred()) SWIG_fail;
23907 }
23908 {
23909 wxTimeSpan * resultptr;
23910 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23911 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23912 }
23913 return resultobj;
23914 fail:
23915 return NULL;
23916 }
23917
23918
23919 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23920 PyObject *resultobj;
23921 long arg1 ;
23922 wxTimeSpan result;
23923 PyObject * obj0 = 0 ;
23924 char *kwnames[] = {
23925 (char *) "min", NULL
23926 };
23927
23928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23929 {
23930 arg1 = (long)(SWIG_As_long(obj0));
23931 if (SWIG_arg_fail(1)) SWIG_fail;
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = wxTimeSpan::Minutes(arg1);
23936
23937 wxPyEndAllowThreads(__tstate);
23938 if (PyErr_Occurred()) SWIG_fail;
23939 }
23940 {
23941 wxTimeSpan * resultptr;
23942 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23944 }
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj;
23953 wxTimeSpan result;
23954 char *kwnames[] = {
23955 NULL
23956 };
23957
23958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = wxTimeSpan::Minute();
23962
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 wxTimeSpan * resultptr;
23968 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23969 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 long arg1 ;
23980 wxTimeSpan result;
23981 PyObject * obj0 = 0 ;
23982 char *kwnames[] = {
23983 (char *) "hours", NULL
23984 };
23985
23986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23987 {
23988 arg1 = (long)(SWIG_As_long(obj0));
23989 if (SWIG_arg_fail(1)) SWIG_fail;
23990 }
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 result = wxTimeSpan::Hours(arg1);
23994
23995 wxPyEndAllowThreads(__tstate);
23996 if (PyErr_Occurred()) SWIG_fail;
23997 }
23998 {
23999 wxTimeSpan * resultptr;
24000 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24001 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24002 }
24003 return resultobj;
24004 fail:
24005 return NULL;
24006 }
24007
24008
24009 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
24010 PyObject *resultobj;
24011 wxTimeSpan result;
24012 char *kwnames[] = {
24013 NULL
24014 };
24015
24016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 result = wxTimeSpan::Hour();
24020
24021 wxPyEndAllowThreads(__tstate);
24022 if (PyErr_Occurred()) SWIG_fail;
24023 }
24024 {
24025 wxTimeSpan * resultptr;
24026 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24036 PyObject *resultobj;
24037 long arg1 ;
24038 wxTimeSpan result;
24039 PyObject * obj0 = 0 ;
24040 char *kwnames[] = {
24041 (char *) "days", NULL
24042 };
24043
24044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24045 {
24046 arg1 = (long)(SWIG_As_long(obj0));
24047 if (SWIG_arg_fail(1)) SWIG_fail;
24048 }
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = wxTimeSpan::Days(arg1);
24052
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 wxTimeSpan * resultptr;
24058 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24059 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24060 }
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24068 PyObject *resultobj;
24069 wxTimeSpan result;
24070 char *kwnames[] = {
24071 NULL
24072 };
24073
24074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24075 {
24076 PyThreadState* __tstate = wxPyBeginAllowThreads();
24077 result = wxTimeSpan::Day();
24078
24079 wxPyEndAllowThreads(__tstate);
24080 if (PyErr_Occurred()) SWIG_fail;
24081 }
24082 {
24083 wxTimeSpan * resultptr;
24084 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24085 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24086 }
24087 return resultobj;
24088 fail:
24089 return NULL;
24090 }
24091
24092
24093 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24094 PyObject *resultobj;
24095 long arg1 ;
24096 wxTimeSpan result;
24097 PyObject * obj0 = 0 ;
24098 char *kwnames[] = {
24099 (char *) "days", NULL
24100 };
24101
24102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24103 {
24104 arg1 = (long)(SWIG_As_long(obj0));
24105 if (SWIG_arg_fail(1)) SWIG_fail;
24106 }
24107 {
24108 PyThreadState* __tstate = wxPyBeginAllowThreads();
24109 result = wxTimeSpan::Weeks(arg1);
24110
24111 wxPyEndAllowThreads(__tstate);
24112 if (PyErr_Occurred()) SWIG_fail;
24113 }
24114 {
24115 wxTimeSpan * resultptr;
24116 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24117 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24126 PyObject *resultobj;
24127 wxTimeSpan result;
24128 char *kwnames[] = {
24129 NULL
24130 };
24131
24132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24133 {
24134 PyThreadState* __tstate = wxPyBeginAllowThreads();
24135 result = wxTimeSpan::Week();
24136
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 {
24141 wxTimeSpan * resultptr;
24142 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24144 }
24145 return resultobj;
24146 fail:
24147 return NULL;
24148 }
24149
24150
24151 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24152 PyObject *resultobj;
24153 long arg1 = (long) 0 ;
24154 long arg2 = (long) 0 ;
24155 long arg3 = (long) 0 ;
24156 long arg4 = (long) 0 ;
24157 wxTimeSpan *result;
24158 PyObject * obj0 = 0 ;
24159 PyObject * obj1 = 0 ;
24160 PyObject * obj2 = 0 ;
24161 PyObject * obj3 = 0 ;
24162 char *kwnames[] = {
24163 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24164 };
24165
24166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24167 if (obj0) {
24168 {
24169 arg1 = (long)(SWIG_As_long(obj0));
24170 if (SWIG_arg_fail(1)) SWIG_fail;
24171 }
24172 }
24173 if (obj1) {
24174 {
24175 arg2 = (long)(SWIG_As_long(obj1));
24176 if (SWIG_arg_fail(2)) SWIG_fail;
24177 }
24178 }
24179 if (obj2) {
24180 {
24181 arg3 = (long)(SWIG_As_long(obj2));
24182 if (SWIG_arg_fail(3)) SWIG_fail;
24183 }
24184 }
24185 if (obj3) {
24186 {
24187 arg4 = (long)(SWIG_As_long(obj3));
24188 if (SWIG_arg_fail(4)) SWIG_fail;
24189 }
24190 }
24191 {
24192 PyThreadState* __tstate = wxPyBeginAllowThreads();
24193 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24194
24195 wxPyEndAllowThreads(__tstate);
24196 if (PyErr_Occurred()) SWIG_fail;
24197 }
24198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24199 return resultobj;
24200 fail:
24201 return NULL;
24202 }
24203
24204
24205 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24206 PyObject *resultobj;
24207 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24208 PyObject * obj0 = 0 ;
24209 char *kwnames[] = {
24210 (char *) "self", NULL
24211 };
24212
24213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24215 if (SWIG_arg_fail(1)) SWIG_fail;
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 delete arg1;
24219
24220 wxPyEndAllowThreads(__tstate);
24221 if (PyErr_Occurred()) SWIG_fail;
24222 }
24223 Py_INCREF(Py_None); resultobj = Py_None;
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24233 wxTimeSpan *arg2 = 0 ;
24234 wxTimeSpan *result;
24235 PyObject * obj0 = 0 ;
24236 PyObject * obj1 = 0 ;
24237 char *kwnames[] = {
24238 (char *) "self",(char *) "diff", NULL
24239 };
24240
24241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24243 if (SWIG_arg_fail(1)) SWIG_fail;
24244 {
24245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(2)) SWIG_fail;
24247 if (arg2 == NULL) {
24248 SWIG_null_ref("wxTimeSpan");
24249 }
24250 if (SWIG_arg_fail(2)) SWIG_fail;
24251 }
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 {
24255 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24256 result = (wxTimeSpan *) &_result_ref;
24257 }
24258
24259 wxPyEndAllowThreads(__tstate);
24260 if (PyErr_Occurred()) SWIG_fail;
24261 }
24262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24270 PyObject *resultobj;
24271 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24272 wxTimeSpan *arg2 = 0 ;
24273 wxTimeSpan *result;
24274 PyObject * obj0 = 0 ;
24275 PyObject * obj1 = 0 ;
24276 char *kwnames[] = {
24277 (char *) "self",(char *) "diff", NULL
24278 };
24279
24280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24282 if (SWIG_arg_fail(1)) SWIG_fail;
24283 {
24284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24285 if (SWIG_arg_fail(2)) SWIG_fail;
24286 if (arg2 == NULL) {
24287 SWIG_null_ref("wxTimeSpan");
24288 }
24289 if (SWIG_arg_fail(2)) SWIG_fail;
24290 }
24291 {
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 {
24294 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24295 result = (wxTimeSpan *) &_result_ref;
24296 }
24297
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24311 int arg2 ;
24312 wxTimeSpan *result;
24313 PyObject * obj0 = 0 ;
24314 PyObject * obj1 = 0 ;
24315 char *kwnames[] = {
24316 (char *) "self",(char *) "n", NULL
24317 };
24318
24319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24321 if (SWIG_arg_fail(1)) SWIG_fail;
24322 {
24323 arg2 = (int)(SWIG_As_int(obj1));
24324 if (SWIG_arg_fail(2)) SWIG_fail;
24325 }
24326 {
24327 PyThreadState* __tstate = wxPyBeginAllowThreads();
24328 {
24329 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24330 result = (wxTimeSpan *) &_result_ref;
24331 }
24332
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24344 PyObject *resultobj;
24345 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24346 wxTimeSpan *result;
24347 PyObject * obj0 = 0 ;
24348 char *kwnames[] = {
24349 (char *) "self", NULL
24350 };
24351
24352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24354 if (SWIG_arg_fail(1)) SWIG_fail;
24355 {
24356 PyThreadState* __tstate = wxPyBeginAllowThreads();
24357 {
24358 wxTimeSpan &_result_ref = (arg1)->Neg();
24359 result = (wxTimeSpan *) &_result_ref;
24360 }
24361
24362 wxPyEndAllowThreads(__tstate);
24363 if (PyErr_Occurred()) SWIG_fail;
24364 }
24365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24366 return resultobj;
24367 fail:
24368 return NULL;
24369 }
24370
24371
24372 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24373 PyObject *resultobj;
24374 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24375 wxTimeSpan result;
24376 PyObject * obj0 = 0 ;
24377 char *kwnames[] = {
24378 (char *) "self", NULL
24379 };
24380
24381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24383 if (SWIG_arg_fail(1)) SWIG_fail;
24384 {
24385 PyThreadState* __tstate = wxPyBeginAllowThreads();
24386 result = ((wxTimeSpan const *)arg1)->Abs();
24387
24388 wxPyEndAllowThreads(__tstate);
24389 if (PyErr_Occurred()) SWIG_fail;
24390 }
24391 {
24392 wxTimeSpan * resultptr;
24393 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24394 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24395 }
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj;
24404 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24405 wxTimeSpan *arg2 = 0 ;
24406 wxTimeSpan *result;
24407 PyObject * obj0 = 0 ;
24408 PyObject * obj1 = 0 ;
24409 char *kwnames[] = {
24410 (char *) "self",(char *) "diff", NULL
24411 };
24412
24413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24415 if (SWIG_arg_fail(1)) SWIG_fail;
24416 {
24417 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24418 if (SWIG_arg_fail(2)) SWIG_fail;
24419 if (arg2 == NULL) {
24420 SWIG_null_ref("wxTimeSpan");
24421 }
24422 if (SWIG_arg_fail(2)) SWIG_fail;
24423 }
24424 {
24425 PyThreadState* __tstate = wxPyBeginAllowThreads();
24426 {
24427 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24428 result = (wxTimeSpan *) &_result_ref;
24429 }
24430
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24435 return resultobj;
24436 fail:
24437 return NULL;
24438 }
24439
24440
24441 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24442 PyObject *resultobj;
24443 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24444 wxTimeSpan *arg2 = 0 ;
24445 wxTimeSpan *result;
24446 PyObject * obj0 = 0 ;
24447 PyObject * obj1 = 0 ;
24448 char *kwnames[] = {
24449 (char *) "self",(char *) "diff", NULL
24450 };
24451
24452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24454 if (SWIG_arg_fail(1)) SWIG_fail;
24455 {
24456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24457 if (SWIG_arg_fail(2)) SWIG_fail;
24458 if (arg2 == NULL) {
24459 SWIG_null_ref("wxTimeSpan");
24460 }
24461 if (SWIG_arg_fail(2)) SWIG_fail;
24462 }
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 {
24466 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24467 result = (wxTimeSpan *) &_result_ref;
24468 }
24469
24470 wxPyEndAllowThreads(__tstate);
24471 if (PyErr_Occurred()) SWIG_fail;
24472 }
24473 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24474 return resultobj;
24475 fail:
24476 return NULL;
24477 }
24478
24479
24480 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24481 PyObject *resultobj;
24482 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24483 int arg2 ;
24484 wxTimeSpan *result;
24485 PyObject * obj0 = 0 ;
24486 PyObject * obj1 = 0 ;
24487 char *kwnames[] = {
24488 (char *) "self",(char *) "n", NULL
24489 };
24490
24491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24493 if (SWIG_arg_fail(1)) SWIG_fail;
24494 {
24495 arg2 = (int)(SWIG_As_int(obj1));
24496 if (SWIG_arg_fail(2)) SWIG_fail;
24497 }
24498 {
24499 PyThreadState* __tstate = wxPyBeginAllowThreads();
24500 {
24501 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24502 result = (wxTimeSpan *) &_result_ref;
24503 }
24504
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24509 return resultobj;
24510 fail:
24511 return NULL;
24512 }
24513
24514
24515 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24516 PyObject *resultobj;
24517 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24518 wxTimeSpan *result;
24519 PyObject * obj0 = 0 ;
24520 char *kwnames[] = {
24521 (char *) "self", NULL
24522 };
24523
24524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24526 if (SWIG_arg_fail(1)) SWIG_fail;
24527 {
24528 PyThreadState* __tstate = wxPyBeginAllowThreads();
24529 {
24530 wxTimeSpan &_result_ref = (arg1)->operator -();
24531 result = (wxTimeSpan *) &_result_ref;
24532 }
24533
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24538 return resultobj;
24539 fail:
24540 return NULL;
24541 }
24542
24543
24544 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24545 PyObject *resultobj;
24546 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24547 wxTimeSpan *arg2 = 0 ;
24548 wxTimeSpan result;
24549 PyObject * obj0 = 0 ;
24550 PyObject * obj1 = 0 ;
24551 char *kwnames[] = {
24552 (char *) "self",(char *) "other", NULL
24553 };
24554
24555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24557 if (SWIG_arg_fail(1)) SWIG_fail;
24558 {
24559 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24560 if (SWIG_arg_fail(2)) SWIG_fail;
24561 if (arg2 == NULL) {
24562 SWIG_null_ref("wxTimeSpan");
24563 }
24564 if (SWIG_arg_fail(2)) SWIG_fail;
24565 }
24566 {
24567 PyThreadState* __tstate = wxPyBeginAllowThreads();
24568 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24569
24570 wxPyEndAllowThreads(__tstate);
24571 if (PyErr_Occurred()) SWIG_fail;
24572 }
24573 {
24574 wxTimeSpan * resultptr;
24575 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24576 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24577 }
24578 return resultobj;
24579 fail:
24580 return NULL;
24581 }
24582
24583
24584 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24585 PyObject *resultobj;
24586 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24587 wxTimeSpan *arg2 = 0 ;
24588 wxTimeSpan result;
24589 PyObject * obj0 = 0 ;
24590 PyObject * obj1 = 0 ;
24591 char *kwnames[] = {
24592 (char *) "self",(char *) "other", NULL
24593 };
24594
24595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24597 if (SWIG_arg_fail(1)) SWIG_fail;
24598 {
24599 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24600 if (SWIG_arg_fail(2)) SWIG_fail;
24601 if (arg2 == NULL) {
24602 SWIG_null_ref("wxTimeSpan");
24603 }
24604 if (SWIG_arg_fail(2)) SWIG_fail;
24605 }
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24609
24610 wxPyEndAllowThreads(__tstate);
24611 if (PyErr_Occurred()) SWIG_fail;
24612 }
24613 {
24614 wxTimeSpan * resultptr;
24615 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24616 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24617 }
24618 return resultobj;
24619 fail:
24620 return NULL;
24621 }
24622
24623
24624 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24625 PyObject *resultobj;
24626 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24627 int arg2 ;
24628 wxTimeSpan result;
24629 PyObject * obj0 = 0 ;
24630 PyObject * obj1 = 0 ;
24631 char *kwnames[] = {
24632 (char *) "self",(char *) "n", NULL
24633 };
24634
24635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24637 if (SWIG_arg_fail(1)) SWIG_fail;
24638 {
24639 arg2 = (int)(SWIG_As_int(obj1));
24640 if (SWIG_arg_fail(2)) SWIG_fail;
24641 }
24642 {
24643 PyThreadState* __tstate = wxPyBeginAllowThreads();
24644 result = wxTimeSpan___mul__(arg1,arg2);
24645
24646 wxPyEndAllowThreads(__tstate);
24647 if (PyErr_Occurred()) SWIG_fail;
24648 }
24649 {
24650 wxTimeSpan * resultptr;
24651 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24653 }
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj;
24662 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24663 int arg2 ;
24664 wxTimeSpan result;
24665 PyObject * obj0 = 0 ;
24666 PyObject * obj1 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self",(char *) "n", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 {
24675 arg2 = (int)(SWIG_As_int(obj1));
24676 if (SWIG_arg_fail(2)) SWIG_fail;
24677 }
24678 {
24679 PyThreadState* __tstate = wxPyBeginAllowThreads();
24680 result = wxTimeSpan___rmul__(arg1,arg2);
24681
24682 wxPyEndAllowThreads(__tstate);
24683 if (PyErr_Occurred()) SWIG_fail;
24684 }
24685 {
24686 wxTimeSpan * resultptr;
24687 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24688 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24689 }
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj;
24698 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24699 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24700 bool result;
24701 PyObject * obj0 = 0 ;
24702 PyObject * obj1 = 0 ;
24703 char *kwnames[] = {
24704 (char *) "self",(char *) "other", NULL
24705 };
24706
24707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24709 if (SWIG_arg_fail(1)) SWIG_fail;
24710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24711 if (SWIG_arg_fail(2)) SWIG_fail;
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24721 }
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24729 PyObject *resultobj;
24730 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24731 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24732 bool result;
24733 PyObject * obj0 = 0 ;
24734 PyObject * obj1 = 0 ;
24735 char *kwnames[] = {
24736 (char *) "self",(char *) "other", NULL
24737 };
24738
24739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24741 if (SWIG_arg_fail(1)) SWIG_fail;
24742 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24743 if (SWIG_arg_fail(2)) SWIG_fail;
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24747
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 {
24752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24753 }
24754 return resultobj;
24755 fail:
24756 return NULL;
24757 }
24758
24759
24760 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24761 PyObject *resultobj;
24762 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24763 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24764 bool result;
24765 PyObject * obj0 = 0 ;
24766 PyObject * obj1 = 0 ;
24767 char *kwnames[] = {
24768 (char *) "self",(char *) "other", NULL
24769 };
24770
24771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24773 if (SWIG_arg_fail(1)) SWIG_fail;
24774 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24775 if (SWIG_arg_fail(2)) SWIG_fail;
24776 {
24777 PyThreadState* __tstate = wxPyBeginAllowThreads();
24778 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24779
24780 wxPyEndAllowThreads(__tstate);
24781 if (PyErr_Occurred()) SWIG_fail;
24782 }
24783 {
24784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24785 }
24786 return resultobj;
24787 fail:
24788 return NULL;
24789 }
24790
24791
24792 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24793 PyObject *resultobj;
24794 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24795 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24796 bool result;
24797 PyObject * obj0 = 0 ;
24798 PyObject * obj1 = 0 ;
24799 char *kwnames[] = {
24800 (char *) "self",(char *) "other", NULL
24801 };
24802
24803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24805 if (SWIG_arg_fail(1)) SWIG_fail;
24806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24807 if (SWIG_arg_fail(2)) SWIG_fail;
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24811
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 {
24816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24817 }
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj;
24826 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24827 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24828 bool result;
24829 PyObject * obj0 = 0 ;
24830 PyObject * obj1 = 0 ;
24831 char *kwnames[] = {
24832 (char *) "self",(char *) "other", NULL
24833 };
24834
24835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24837 if (SWIG_arg_fail(1)) SWIG_fail;
24838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(2)) SWIG_fail;
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24843
24844 wxPyEndAllowThreads(__tstate);
24845 if (PyErr_Occurred()) SWIG_fail;
24846 }
24847 {
24848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24849 }
24850 return resultobj;
24851 fail:
24852 return NULL;
24853 }
24854
24855
24856 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24857 PyObject *resultobj;
24858 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24859 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24860 bool result;
24861 PyObject * obj0 = 0 ;
24862 PyObject * obj1 = 0 ;
24863 char *kwnames[] = {
24864 (char *) "self",(char *) "other", NULL
24865 };
24866
24867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24869 if (SWIG_arg_fail(1)) SWIG_fail;
24870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24871 if (SWIG_arg_fail(2)) SWIG_fail;
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24875
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 {
24880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24891 bool result;
24892 PyObject * obj0 = 0 ;
24893 char *kwnames[] = {
24894 (char *) "self", NULL
24895 };
24896
24897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24899 if (SWIG_arg_fail(1)) SWIG_fail;
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24903
24904 wxPyEndAllowThreads(__tstate);
24905 if (PyErr_Occurred()) SWIG_fail;
24906 }
24907 {
24908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24917 PyObject *resultobj;
24918 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24919 bool result;
24920 PyObject * obj0 = 0 ;
24921 char *kwnames[] = {
24922 (char *) "self", NULL
24923 };
24924
24925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24927 if (SWIG_arg_fail(1)) SWIG_fail;
24928 {
24929 PyThreadState* __tstate = wxPyBeginAllowThreads();
24930 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24931
24932 wxPyEndAllowThreads(__tstate);
24933 if (PyErr_Occurred()) SWIG_fail;
24934 }
24935 {
24936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24937 }
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24947 bool result;
24948 PyObject * obj0 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 {
24957 PyThreadState* __tstate = wxPyBeginAllowThreads();
24958 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24959
24960 wxPyEndAllowThreads(__tstate);
24961 if (PyErr_Occurred()) SWIG_fail;
24962 }
24963 {
24964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24965 }
24966 return resultobj;
24967 fail:
24968 return NULL;
24969 }
24970
24971
24972 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24975 wxTimeSpan *arg2 = 0 ;
24976 bool result;
24977 PyObject * obj0 = 0 ;
24978 PyObject * obj1 = 0 ;
24979 char *kwnames[] = {
24980 (char *) "self",(char *) "ts", NULL
24981 };
24982
24983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24985 if (SWIG_arg_fail(1)) SWIG_fail;
24986 {
24987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24988 if (SWIG_arg_fail(2)) SWIG_fail;
24989 if (arg2 == NULL) {
24990 SWIG_null_ref("wxTimeSpan");
24991 }
24992 if (SWIG_arg_fail(2)) SWIG_fail;
24993 }
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24997
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj;
25012 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25013 wxTimeSpan *arg2 = 0 ;
25014 bool result;
25015 PyObject * obj0 = 0 ;
25016 PyObject * obj1 = 0 ;
25017 char *kwnames[] = {
25018 (char *) "self",(char *) "ts", NULL
25019 };
25020
25021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
25022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25023 if (SWIG_arg_fail(1)) SWIG_fail;
25024 {
25025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25026 if (SWIG_arg_fail(2)) SWIG_fail;
25027 if (arg2 == NULL) {
25028 SWIG_null_ref("wxTimeSpan");
25029 }
25030 if (SWIG_arg_fail(2)) SWIG_fail;
25031 }
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
25035
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25041 }
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj;
25050 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25051 wxTimeSpan *arg2 = 0 ;
25052 bool result;
25053 PyObject * obj0 = 0 ;
25054 PyObject * obj1 = 0 ;
25055 char *kwnames[] = {
25056 (char *) "self",(char *) "t", NULL
25057 };
25058
25059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25061 if (SWIG_arg_fail(1)) SWIG_fail;
25062 {
25063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25064 if (SWIG_arg_fail(2)) SWIG_fail;
25065 if (arg2 == NULL) {
25066 SWIG_null_ref("wxTimeSpan");
25067 }
25068 if (SWIG_arg_fail(2)) SWIG_fail;
25069 }
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25073
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 {
25078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25087 PyObject *resultobj;
25088 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25089 int result;
25090 PyObject * obj0 = 0 ;
25091 char *kwnames[] = {
25092 (char *) "self", NULL
25093 };
25094
25095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25097 if (SWIG_arg_fail(1)) SWIG_fail;
25098 {
25099 PyThreadState* __tstate = wxPyBeginAllowThreads();
25100 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25101
25102 wxPyEndAllowThreads(__tstate);
25103 if (PyErr_Occurred()) SWIG_fail;
25104 }
25105 {
25106 resultobj = SWIG_From_int((int)(result));
25107 }
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj;
25116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25117 int result;
25118 PyObject * obj0 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 {
25134 resultobj = SWIG_From_int((int)(result));
25135 }
25136 return resultobj;
25137 fail:
25138 return NULL;
25139 }
25140
25141
25142 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25143 PyObject *resultobj;
25144 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25145 int result;
25146 PyObject * obj0 = 0 ;
25147 char *kwnames[] = {
25148 (char *) "self", NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25153 if (SWIG_arg_fail(1)) SWIG_fail;
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = SWIG_From_int((int)(result));
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25171 PyObject *resultobj;
25172 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25173 int result;
25174 PyObject * obj0 = 0 ;
25175 char *kwnames[] = {
25176 (char *) "self", NULL
25177 };
25178
25179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25181 if (SWIG_arg_fail(1)) SWIG_fail;
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25185
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 {
25190 resultobj = SWIG_From_int((int)(result));
25191 }
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25201 wxLongLong result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "self", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 {
25218 PyObject *hi, *lo, *shifter, *shifted;
25219 hi = PyLong_FromLong( (&result)->GetHi() );
25220 lo = PyLong_FromLong( (&result)->GetLo() );
25221 shifter = PyLong_FromLong(32);
25222 shifted = PyNumber_Lshift(hi, shifter);
25223 resultobj = PyNumber_Or(shifted, lo);
25224 Py_DECREF(hi);
25225 Py_DECREF(lo);
25226 Py_DECREF(shifter);
25227 Py_DECREF(shifted);
25228 }
25229 return resultobj;
25230 fail:
25231 return NULL;
25232 }
25233
25234
25235 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25236 PyObject *resultobj;
25237 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25238 wxLongLong result;
25239 PyObject * obj0 = 0 ;
25240 char *kwnames[] = {
25241 (char *) "self", NULL
25242 };
25243
25244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25246 if (SWIG_arg_fail(1)) SWIG_fail;
25247 {
25248 PyThreadState* __tstate = wxPyBeginAllowThreads();
25249 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25250
25251 wxPyEndAllowThreads(__tstate);
25252 if (PyErr_Occurred()) SWIG_fail;
25253 }
25254 {
25255 PyObject *hi, *lo, *shifter, *shifted;
25256 hi = PyLong_FromLong( (&result)->GetHi() );
25257 lo = PyLong_FromLong( (&result)->GetLo() );
25258 shifter = PyLong_FromLong(32);
25259 shifted = PyNumber_Lshift(hi, shifter);
25260 resultobj = PyNumber_Or(shifted, lo);
25261 Py_DECREF(hi);
25262 Py_DECREF(lo);
25263 Py_DECREF(shifter);
25264 Py_DECREF(shifted);
25265 }
25266 return resultobj;
25267 fail:
25268 return NULL;
25269 }
25270
25271
25272 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25273 PyObject *resultobj;
25274 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25275 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25276 wxString *arg2 = (wxString *) &arg2_defvalue ;
25277 wxString result;
25278 bool temp2 = false ;
25279 PyObject * obj0 = 0 ;
25280 PyObject * obj1 = 0 ;
25281 char *kwnames[] = {
25282 (char *) "self",(char *) "format", NULL
25283 };
25284
25285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25287 if (SWIG_arg_fail(1)) SWIG_fail;
25288 if (obj1) {
25289 {
25290 arg2 = wxString_in_helper(obj1);
25291 if (arg2 == NULL) SWIG_fail;
25292 temp2 = true;
25293 }
25294 }
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25298
25299 wxPyEndAllowThreads(__tstate);
25300 if (PyErr_Occurred()) SWIG_fail;
25301 }
25302 {
25303 #if wxUSE_UNICODE
25304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25305 #else
25306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25307 #endif
25308 }
25309 {
25310 if (temp2)
25311 delete arg2;
25312 }
25313 return resultobj;
25314 fail:
25315 {
25316 if (temp2)
25317 delete arg2;
25318 }
25319 return NULL;
25320 }
25321
25322
25323 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25324 PyObject *obj;
25325 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25326 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25327 Py_INCREF(obj);
25328 return Py_BuildValue((char *)"");
25329 }
25330 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25331 PyObject *resultobj;
25332 int arg1 = (int) 0 ;
25333 int arg2 = (int) 0 ;
25334 int arg3 = (int) 0 ;
25335 int arg4 = (int) 0 ;
25336 wxDateSpan *result;
25337 PyObject * obj0 = 0 ;
25338 PyObject * obj1 = 0 ;
25339 PyObject * obj2 = 0 ;
25340 PyObject * obj3 = 0 ;
25341 char *kwnames[] = {
25342 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25343 };
25344
25345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25346 if (obj0) {
25347 {
25348 arg1 = (int)(SWIG_As_int(obj0));
25349 if (SWIG_arg_fail(1)) SWIG_fail;
25350 }
25351 }
25352 if (obj1) {
25353 {
25354 arg2 = (int)(SWIG_As_int(obj1));
25355 if (SWIG_arg_fail(2)) SWIG_fail;
25356 }
25357 }
25358 if (obj2) {
25359 {
25360 arg3 = (int)(SWIG_As_int(obj2));
25361 if (SWIG_arg_fail(3)) SWIG_fail;
25362 }
25363 }
25364 if (obj3) {
25365 {
25366 arg4 = (int)(SWIG_As_int(obj3));
25367 if (SWIG_arg_fail(4)) SWIG_fail;
25368 }
25369 }
25370 {
25371 PyThreadState* __tstate = wxPyBeginAllowThreads();
25372 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25373
25374 wxPyEndAllowThreads(__tstate);
25375 if (PyErr_Occurred()) SWIG_fail;
25376 }
25377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25378 return resultobj;
25379 fail:
25380 return NULL;
25381 }
25382
25383
25384 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25385 PyObject *resultobj;
25386 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25387 PyObject * obj0 = 0 ;
25388 char *kwnames[] = {
25389 (char *) "self", NULL
25390 };
25391
25392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25394 if (SWIG_arg_fail(1)) SWIG_fail;
25395 {
25396 PyThreadState* __tstate = wxPyBeginAllowThreads();
25397 delete arg1;
25398
25399 wxPyEndAllowThreads(__tstate);
25400 if (PyErr_Occurred()) SWIG_fail;
25401 }
25402 Py_INCREF(Py_None); resultobj = Py_None;
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj;
25411 int arg1 ;
25412 wxDateSpan result;
25413 PyObject * obj0 = 0 ;
25414 char *kwnames[] = {
25415 (char *) "days", NULL
25416 };
25417
25418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25419 {
25420 arg1 = (int)(SWIG_As_int(obj0));
25421 if (SWIG_arg_fail(1)) SWIG_fail;
25422 }
25423 {
25424 PyThreadState* __tstate = wxPyBeginAllowThreads();
25425 result = wxDateSpan::Days(arg1);
25426
25427 wxPyEndAllowThreads(__tstate);
25428 if (PyErr_Occurred()) SWIG_fail;
25429 }
25430 {
25431 wxDateSpan * resultptr;
25432 resultptr = new wxDateSpan((wxDateSpan &)(result));
25433 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25434 }
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25442 PyObject *resultobj;
25443 wxDateSpan result;
25444 char *kwnames[] = {
25445 NULL
25446 };
25447
25448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = wxDateSpan::Day();
25452
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 wxDateSpan * resultptr;
25458 resultptr = new wxDateSpan((wxDateSpan &)(result));
25459 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25460 }
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj;
25469 int arg1 ;
25470 wxDateSpan result;
25471 PyObject * obj0 = 0 ;
25472 char *kwnames[] = {
25473 (char *) "weeks", NULL
25474 };
25475
25476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25477 {
25478 arg1 = (int)(SWIG_As_int(obj0));
25479 if (SWIG_arg_fail(1)) SWIG_fail;
25480 }
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = wxDateSpan::Weeks(arg1);
25484
25485 wxPyEndAllowThreads(__tstate);
25486 if (PyErr_Occurred()) SWIG_fail;
25487 }
25488 {
25489 wxDateSpan * resultptr;
25490 resultptr = new wxDateSpan((wxDateSpan &)(result));
25491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25492 }
25493 return resultobj;
25494 fail:
25495 return NULL;
25496 }
25497
25498
25499 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25500 PyObject *resultobj;
25501 wxDateSpan result;
25502 char *kwnames[] = {
25503 NULL
25504 };
25505
25506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = wxDateSpan::Week();
25510
25511 wxPyEndAllowThreads(__tstate);
25512 if (PyErr_Occurred()) SWIG_fail;
25513 }
25514 {
25515 wxDateSpan * resultptr;
25516 resultptr = new wxDateSpan((wxDateSpan &)(result));
25517 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25518 }
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25526 PyObject *resultobj;
25527 int arg1 ;
25528 wxDateSpan result;
25529 PyObject * obj0 = 0 ;
25530 char *kwnames[] = {
25531 (char *) "mon", NULL
25532 };
25533
25534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25535 {
25536 arg1 = (int)(SWIG_As_int(obj0));
25537 if (SWIG_arg_fail(1)) SWIG_fail;
25538 }
25539 {
25540 PyThreadState* __tstate = wxPyBeginAllowThreads();
25541 result = wxDateSpan::Months(arg1);
25542
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 {
25547 wxDateSpan * resultptr;
25548 resultptr = new wxDateSpan((wxDateSpan &)(result));
25549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25550 }
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25558 PyObject *resultobj;
25559 wxDateSpan result;
25560 char *kwnames[] = {
25561 NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25565 {
25566 PyThreadState* __tstate = wxPyBeginAllowThreads();
25567 result = wxDateSpan::Month();
25568
25569 wxPyEndAllowThreads(__tstate);
25570 if (PyErr_Occurred()) SWIG_fail;
25571 }
25572 {
25573 wxDateSpan * resultptr;
25574 resultptr = new wxDateSpan((wxDateSpan &)(result));
25575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25576 }
25577 return resultobj;
25578 fail:
25579 return NULL;
25580 }
25581
25582
25583 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25584 PyObject *resultobj;
25585 int arg1 ;
25586 wxDateSpan result;
25587 PyObject * obj0 = 0 ;
25588 char *kwnames[] = {
25589 (char *) "years", NULL
25590 };
25591
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25593 {
25594 arg1 = (int)(SWIG_As_int(obj0));
25595 if (SWIG_arg_fail(1)) SWIG_fail;
25596 }
25597 {
25598 PyThreadState* __tstate = wxPyBeginAllowThreads();
25599 result = wxDateSpan::Years(arg1);
25600
25601 wxPyEndAllowThreads(__tstate);
25602 if (PyErr_Occurred()) SWIG_fail;
25603 }
25604 {
25605 wxDateSpan * resultptr;
25606 resultptr = new wxDateSpan((wxDateSpan &)(result));
25607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25608 }
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25616 PyObject *resultobj;
25617 wxDateSpan result;
25618 char *kwnames[] = {
25619 NULL
25620 };
25621
25622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 result = wxDateSpan::Year();
25626
25627 wxPyEndAllowThreads(__tstate);
25628 if (PyErr_Occurred()) SWIG_fail;
25629 }
25630 {
25631 wxDateSpan * resultptr;
25632 resultptr = new wxDateSpan((wxDateSpan &)(result));
25633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25634 }
25635 return resultobj;
25636 fail:
25637 return NULL;
25638 }
25639
25640
25641 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25642 PyObject *resultobj;
25643 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25644 int arg2 ;
25645 wxDateSpan *result;
25646 PyObject * obj0 = 0 ;
25647 PyObject * obj1 = 0 ;
25648 char *kwnames[] = {
25649 (char *) "self",(char *) "n", NULL
25650 };
25651
25652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25654 if (SWIG_arg_fail(1)) SWIG_fail;
25655 {
25656 arg2 = (int)(SWIG_As_int(obj1));
25657 if (SWIG_arg_fail(2)) SWIG_fail;
25658 }
25659 {
25660 PyThreadState* __tstate = wxPyBeginAllowThreads();
25661 {
25662 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25663 result = (wxDateSpan *) &_result_ref;
25664 }
25665
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25677 PyObject *resultobj;
25678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25679 int arg2 ;
25680 wxDateSpan *result;
25681 PyObject * obj0 = 0 ;
25682 PyObject * obj1 = 0 ;
25683 char *kwnames[] = {
25684 (char *) "self",(char *) "n", NULL
25685 };
25686
25687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25689 if (SWIG_arg_fail(1)) SWIG_fail;
25690 {
25691 arg2 = (int)(SWIG_As_int(obj1));
25692 if (SWIG_arg_fail(2)) SWIG_fail;
25693 }
25694 {
25695 PyThreadState* __tstate = wxPyBeginAllowThreads();
25696 {
25697 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25698 result = (wxDateSpan *) &_result_ref;
25699 }
25700
25701 wxPyEndAllowThreads(__tstate);
25702 if (PyErr_Occurred()) SWIG_fail;
25703 }
25704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25705 return resultobj;
25706 fail:
25707 return NULL;
25708 }
25709
25710
25711 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25712 PyObject *resultobj;
25713 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25714 int arg2 ;
25715 wxDateSpan *result;
25716 PyObject * obj0 = 0 ;
25717 PyObject * obj1 = 0 ;
25718 char *kwnames[] = {
25719 (char *) "self",(char *) "n", NULL
25720 };
25721
25722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25724 if (SWIG_arg_fail(1)) SWIG_fail;
25725 {
25726 arg2 = (int)(SWIG_As_int(obj1));
25727 if (SWIG_arg_fail(2)) SWIG_fail;
25728 }
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 {
25732 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25733 result = (wxDateSpan *) &_result_ref;
25734 }
25735
25736 wxPyEndAllowThreads(__tstate);
25737 if (PyErr_Occurred()) SWIG_fail;
25738 }
25739 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25740 return resultobj;
25741 fail:
25742 return NULL;
25743 }
25744
25745
25746 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25747 PyObject *resultobj;
25748 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25749 int arg2 ;
25750 wxDateSpan *result;
25751 PyObject * obj0 = 0 ;
25752 PyObject * obj1 = 0 ;
25753 char *kwnames[] = {
25754 (char *) "self",(char *) "n", NULL
25755 };
25756
25757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25759 if (SWIG_arg_fail(1)) SWIG_fail;
25760 {
25761 arg2 = (int)(SWIG_As_int(obj1));
25762 if (SWIG_arg_fail(2)) SWIG_fail;
25763 }
25764 {
25765 PyThreadState* __tstate = wxPyBeginAllowThreads();
25766 {
25767 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25768 result = (wxDateSpan *) &_result_ref;
25769 }
25770
25771 wxPyEndAllowThreads(__tstate);
25772 if (PyErr_Occurred()) SWIG_fail;
25773 }
25774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25775 return resultobj;
25776 fail:
25777 return NULL;
25778 }
25779
25780
25781 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25782 PyObject *resultobj;
25783 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25784 int result;
25785 PyObject * obj0 = 0 ;
25786 char *kwnames[] = {
25787 (char *) "self", NULL
25788 };
25789
25790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25792 if (SWIG_arg_fail(1)) SWIG_fail;
25793 {
25794 PyThreadState* __tstate = wxPyBeginAllowThreads();
25795 result = (int)((wxDateSpan const *)arg1)->GetYears();
25796
25797 wxPyEndAllowThreads(__tstate);
25798 if (PyErr_Occurred()) SWIG_fail;
25799 }
25800 {
25801 resultobj = SWIG_From_int((int)(result));
25802 }
25803 return resultobj;
25804 fail:
25805 return NULL;
25806 }
25807
25808
25809 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj;
25811 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25812 int result;
25813 PyObject * obj0 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self", NULL
25816 };
25817
25818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25820 if (SWIG_arg_fail(1)) SWIG_fail;
25821 {
25822 PyThreadState* __tstate = wxPyBeginAllowThreads();
25823 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25824
25825 wxPyEndAllowThreads(__tstate);
25826 if (PyErr_Occurred()) SWIG_fail;
25827 }
25828 {
25829 resultobj = SWIG_From_int((int)(result));
25830 }
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25838 PyObject *resultobj;
25839 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25840 int result;
25841 PyObject * obj0 = 0 ;
25842 char *kwnames[] = {
25843 (char *) "self", NULL
25844 };
25845
25846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25848 if (SWIG_arg_fail(1)) SWIG_fail;
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25852
25853 wxPyEndAllowThreads(__tstate);
25854 if (PyErr_Occurred()) SWIG_fail;
25855 }
25856 {
25857 resultobj = SWIG_From_int((int)(result));
25858 }
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25866 PyObject *resultobj;
25867 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25868 int result;
25869 PyObject * obj0 = 0 ;
25870 char *kwnames[] = {
25871 (char *) "self", NULL
25872 };
25873
25874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25876 if (SWIG_arg_fail(1)) SWIG_fail;
25877 {
25878 PyThreadState* __tstate = wxPyBeginAllowThreads();
25879 result = (int)((wxDateSpan const *)arg1)->GetDays();
25880
25881 wxPyEndAllowThreads(__tstate);
25882 if (PyErr_Occurred()) SWIG_fail;
25883 }
25884 {
25885 resultobj = SWIG_From_int((int)(result));
25886 }
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25896 int result;
25897 PyObject * obj0 = 0 ;
25898 char *kwnames[] = {
25899 (char *) "self", NULL
25900 };
25901
25902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25904 if (SWIG_arg_fail(1)) SWIG_fail;
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25908
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 {
25913 resultobj = SWIG_From_int((int)(result));
25914 }
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25924 wxDateSpan *arg2 = 0 ;
25925 wxDateSpan *result;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 char *kwnames[] = {
25929 (char *) "self",(char *) "other", NULL
25930 };
25931
25932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25934 if (SWIG_arg_fail(1)) SWIG_fail;
25935 {
25936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(2)) SWIG_fail;
25938 if (arg2 == NULL) {
25939 SWIG_null_ref("wxDateSpan");
25940 }
25941 if (SWIG_arg_fail(2)) SWIG_fail;
25942 }
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 {
25946 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25947 result = (wxDateSpan *) &_result_ref;
25948 }
25949
25950 wxPyEndAllowThreads(__tstate);
25951 if (PyErr_Occurred()) SWIG_fail;
25952 }
25953 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25954 return resultobj;
25955 fail:
25956 return NULL;
25957 }
25958
25959
25960 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25961 PyObject *resultobj;
25962 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25963 wxDateSpan *arg2 = 0 ;
25964 wxDateSpan *result;
25965 PyObject * obj0 = 0 ;
25966 PyObject * obj1 = 0 ;
25967 char *kwnames[] = {
25968 (char *) "self",(char *) "other", NULL
25969 };
25970
25971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25973 if (SWIG_arg_fail(1)) SWIG_fail;
25974 {
25975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25976 if (SWIG_arg_fail(2)) SWIG_fail;
25977 if (arg2 == NULL) {
25978 SWIG_null_ref("wxDateSpan");
25979 }
25980 if (SWIG_arg_fail(2)) SWIG_fail;
25981 }
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 {
25985 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25986 result = (wxDateSpan *) &_result_ref;
25987 }
25988
25989 wxPyEndAllowThreads(__tstate);
25990 if (PyErr_Occurred()) SWIG_fail;
25991 }
25992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25993 return resultobj;
25994 fail:
25995 return NULL;
25996 }
25997
25998
25999 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
26000 PyObject *resultobj;
26001 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26002 wxDateSpan *result;
26003 PyObject * obj0 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 {
26014 wxDateSpan &_result_ref = (arg1)->Neg();
26015 result = (wxDateSpan *) &_result_ref;
26016 }
26017
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
26029 PyObject *resultobj;
26030 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26031 int arg2 ;
26032 wxDateSpan *result;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char *kwnames[] = {
26036 (char *) "self",(char *) "factor", NULL
26037 };
26038
26039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26041 if (SWIG_arg_fail(1)) SWIG_fail;
26042 {
26043 arg2 = (int)(SWIG_As_int(obj1));
26044 if (SWIG_arg_fail(2)) SWIG_fail;
26045 }
26046 {
26047 PyThreadState* __tstate = wxPyBeginAllowThreads();
26048 {
26049 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26050 result = (wxDateSpan *) &_result_ref;
26051 }
26052
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26064 PyObject *resultobj;
26065 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26066 wxDateSpan *arg2 = 0 ;
26067 wxDateSpan *result;
26068 PyObject * obj0 = 0 ;
26069 PyObject * obj1 = 0 ;
26070 char *kwnames[] = {
26071 (char *) "self",(char *) "other", NULL
26072 };
26073
26074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26076 if (SWIG_arg_fail(1)) SWIG_fail;
26077 {
26078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26079 if (SWIG_arg_fail(2)) SWIG_fail;
26080 if (arg2 == NULL) {
26081 SWIG_null_ref("wxDateSpan");
26082 }
26083 if (SWIG_arg_fail(2)) SWIG_fail;
26084 }
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 {
26088 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26089 result = (wxDateSpan *) &_result_ref;
26090 }
26091
26092 wxPyEndAllowThreads(__tstate);
26093 if (PyErr_Occurred()) SWIG_fail;
26094 }
26095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26103 PyObject *resultobj;
26104 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26105 wxDateSpan *arg2 = 0 ;
26106 wxDateSpan *result;
26107 PyObject * obj0 = 0 ;
26108 PyObject * obj1 = 0 ;
26109 char *kwnames[] = {
26110 (char *) "self",(char *) "other", NULL
26111 };
26112
26113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26115 if (SWIG_arg_fail(1)) SWIG_fail;
26116 {
26117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26118 if (SWIG_arg_fail(2)) SWIG_fail;
26119 if (arg2 == NULL) {
26120 SWIG_null_ref("wxDateSpan");
26121 }
26122 if (SWIG_arg_fail(2)) SWIG_fail;
26123 }
26124 {
26125 PyThreadState* __tstate = wxPyBeginAllowThreads();
26126 {
26127 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26128 result = (wxDateSpan *) &_result_ref;
26129 }
26130
26131 wxPyEndAllowThreads(__tstate);
26132 if (PyErr_Occurred()) SWIG_fail;
26133 }
26134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26135 return resultobj;
26136 fail:
26137 return NULL;
26138 }
26139
26140
26141 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26142 PyObject *resultobj;
26143 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26144 wxDateSpan *result;
26145 PyObject * obj0 = 0 ;
26146 char *kwnames[] = {
26147 (char *) "self", NULL
26148 };
26149
26150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26152 if (SWIG_arg_fail(1)) SWIG_fail;
26153 {
26154 PyThreadState* __tstate = wxPyBeginAllowThreads();
26155 {
26156 wxDateSpan &_result_ref = (arg1)->operator -();
26157 result = (wxDateSpan *) &_result_ref;
26158 }
26159
26160 wxPyEndAllowThreads(__tstate);
26161 if (PyErr_Occurred()) SWIG_fail;
26162 }
26163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj;
26172 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26173 int arg2 ;
26174 wxDateSpan *result;
26175 PyObject * obj0 = 0 ;
26176 PyObject * obj1 = 0 ;
26177 char *kwnames[] = {
26178 (char *) "self",(char *) "factor", NULL
26179 };
26180
26181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26183 if (SWIG_arg_fail(1)) SWIG_fail;
26184 {
26185 arg2 = (int)(SWIG_As_int(obj1));
26186 if (SWIG_arg_fail(2)) SWIG_fail;
26187 }
26188 {
26189 PyThreadState* __tstate = wxPyBeginAllowThreads();
26190 {
26191 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26192 result = (wxDateSpan *) &_result_ref;
26193 }
26194
26195 wxPyEndAllowThreads(__tstate);
26196 if (PyErr_Occurred()) SWIG_fail;
26197 }
26198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26206 PyObject *resultobj;
26207 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26208 wxDateSpan *arg2 = 0 ;
26209 wxDateSpan result;
26210 PyObject * obj0 = 0 ;
26211 PyObject * obj1 = 0 ;
26212 char *kwnames[] = {
26213 (char *) "self",(char *) "other", NULL
26214 };
26215
26216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(1)) SWIG_fail;
26219 {
26220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26221 if (SWIG_arg_fail(2)) SWIG_fail;
26222 if (arg2 == NULL) {
26223 SWIG_null_ref("wxDateSpan");
26224 }
26225 if (SWIG_arg_fail(2)) SWIG_fail;
26226 }
26227 {
26228 PyThreadState* __tstate = wxPyBeginAllowThreads();
26229 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26230
26231 wxPyEndAllowThreads(__tstate);
26232 if (PyErr_Occurred()) SWIG_fail;
26233 }
26234 {
26235 wxDateSpan * resultptr;
26236 resultptr = new wxDateSpan((wxDateSpan &)(result));
26237 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26238 }
26239 return resultobj;
26240 fail:
26241 return NULL;
26242 }
26243
26244
26245 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26246 PyObject *resultobj;
26247 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26248 wxDateSpan *arg2 = 0 ;
26249 wxDateSpan result;
26250 PyObject * obj0 = 0 ;
26251 PyObject * obj1 = 0 ;
26252 char *kwnames[] = {
26253 (char *) "self",(char *) "other", NULL
26254 };
26255
26256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26258 if (SWIG_arg_fail(1)) SWIG_fail;
26259 {
26260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26261 if (SWIG_arg_fail(2)) SWIG_fail;
26262 if (arg2 == NULL) {
26263 SWIG_null_ref("wxDateSpan");
26264 }
26265 if (SWIG_arg_fail(2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26270
26271 wxPyEndAllowThreads(__tstate);
26272 if (PyErr_Occurred()) SWIG_fail;
26273 }
26274 {
26275 wxDateSpan * resultptr;
26276 resultptr = new wxDateSpan((wxDateSpan &)(result));
26277 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26278 }
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26286 PyObject *resultobj;
26287 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26288 int arg2 ;
26289 wxDateSpan result;
26290 PyObject * obj0 = 0 ;
26291 PyObject * obj1 = 0 ;
26292 char *kwnames[] = {
26293 (char *) "self",(char *) "n", NULL
26294 };
26295
26296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26298 if (SWIG_arg_fail(1)) SWIG_fail;
26299 {
26300 arg2 = (int)(SWIG_As_int(obj1));
26301 if (SWIG_arg_fail(2)) SWIG_fail;
26302 }
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 result = wxDateSpan___mul__(arg1,arg2);
26306
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 {
26311 wxDateSpan * resultptr;
26312 resultptr = new wxDateSpan((wxDateSpan &)(result));
26313 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26314 }
26315 return resultobj;
26316 fail:
26317 return NULL;
26318 }
26319
26320
26321 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26322 PyObject *resultobj;
26323 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26324 int arg2 ;
26325 wxDateSpan result;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self",(char *) "n", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26334 if (SWIG_arg_fail(1)) SWIG_fail;
26335 {
26336 arg2 = (int)(SWIG_As_int(obj1));
26337 if (SWIG_arg_fail(2)) SWIG_fail;
26338 }
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 result = wxDateSpan___rmul__(arg1,arg2);
26342
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 {
26347 wxDateSpan * resultptr;
26348 resultptr = new wxDateSpan((wxDateSpan &)(result));
26349 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26350 }
26351 return resultobj;
26352 fail:
26353 return NULL;
26354 }
26355
26356
26357 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26358 PyObject *resultobj;
26359 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26360 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26361 bool result;
26362 PyObject * obj0 = 0 ;
26363 PyObject * obj1 = 0 ;
26364 char *kwnames[] = {
26365 (char *) "self",(char *) "other", NULL
26366 };
26367
26368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26370 if (SWIG_arg_fail(1)) SWIG_fail;
26371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26372 if (SWIG_arg_fail(2)) SWIG_fail;
26373 {
26374 PyThreadState* __tstate = wxPyBeginAllowThreads();
26375 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26376
26377 wxPyEndAllowThreads(__tstate);
26378 if (PyErr_Occurred()) SWIG_fail;
26379 }
26380 {
26381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26382 }
26383 return resultobj;
26384 fail:
26385 return NULL;
26386 }
26387
26388
26389 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj;
26391 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26392 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26393 bool result;
26394 PyObject * obj0 = 0 ;
26395 PyObject * obj1 = 0 ;
26396 char *kwnames[] = {
26397 (char *) "self",(char *) "other", NULL
26398 };
26399
26400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26402 if (SWIG_arg_fail(1)) SWIG_fail;
26403 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26404 if (SWIG_arg_fail(2)) SWIG_fail;
26405 {
26406 PyThreadState* __tstate = wxPyBeginAllowThreads();
26407 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26408
26409 wxPyEndAllowThreads(__tstate);
26410 if (PyErr_Occurred()) SWIG_fail;
26411 }
26412 {
26413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26422 PyObject *obj;
26423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26424 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26425 Py_INCREF(obj);
26426 return Py_BuildValue((char *)"");
26427 }
26428 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26429 PyObject *resultobj;
26430 long result;
26431 char *kwnames[] = {
26432 NULL
26433 };
26434
26435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (long)wxGetLocalTime();
26439
26440 wxPyEndAllowThreads(__tstate);
26441 if (PyErr_Occurred()) SWIG_fail;
26442 }
26443 {
26444 resultobj = SWIG_From_long((long)(result));
26445 }
26446 return resultobj;
26447 fail:
26448 return NULL;
26449 }
26450
26451
26452 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26453 PyObject *resultobj;
26454 long result;
26455 char *kwnames[] = {
26456 NULL
26457 };
26458
26459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26460 {
26461 PyThreadState* __tstate = wxPyBeginAllowThreads();
26462 result = (long)wxGetUTCTime();
26463
26464 wxPyEndAllowThreads(__tstate);
26465 if (PyErr_Occurred()) SWIG_fail;
26466 }
26467 {
26468 resultobj = SWIG_From_long((long)(result));
26469 }
26470 return resultobj;
26471 fail:
26472 return NULL;
26473 }
26474
26475
26476 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj;
26478 long result;
26479 char *kwnames[] = {
26480 NULL
26481 };
26482
26483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26484 {
26485 PyThreadState* __tstate = wxPyBeginAllowThreads();
26486 result = (long)wxGetCurrentTime();
26487
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 {
26492 resultobj = SWIG_From_long((long)(result));
26493 }
26494 return resultobj;
26495 fail:
26496 return NULL;
26497 }
26498
26499
26500 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26501 PyObject *resultobj;
26502 wxLongLong result;
26503 char *kwnames[] = {
26504 NULL
26505 };
26506
26507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26508 {
26509 PyThreadState* __tstate = wxPyBeginAllowThreads();
26510 result = wxGetLocalTimeMillis();
26511
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 {
26516 PyObject *hi, *lo, *shifter, *shifted;
26517 hi = PyLong_FromLong( (&result)->GetHi() );
26518 lo = PyLong_FromLong( (&result)->GetLo() );
26519 shifter = PyLong_FromLong(32);
26520 shifted = PyNumber_Lshift(hi, shifter);
26521 resultobj = PyNumber_Or(shifted, lo);
26522 Py_DECREF(hi);
26523 Py_DECREF(lo);
26524 Py_DECREF(shifter);
26525 Py_DECREF(shifted);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 static int _wrap_DefaultDateTime_set(PyObject *) {
26534 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26535 return 1;
26536 }
26537
26538
26539 static PyObject *_wrap_DefaultDateTime_get(void) {
26540 PyObject *pyobj;
26541
26542 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26543 return pyobj;
26544 }
26545
26546
26547 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26548 PyObject *resultobj;
26549 wxDataFormatId arg1 ;
26550 wxDataFormat *result;
26551 PyObject * obj0 = 0 ;
26552 char *kwnames[] = {
26553 (char *) "type", NULL
26554 };
26555
26556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26557 {
26558 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26559 if (SWIG_arg_fail(1)) SWIG_fail;
26560 }
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26569 return resultobj;
26570 fail:
26571 return NULL;
26572 }
26573
26574
26575 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26576 PyObject *resultobj;
26577 wxString *arg1 = 0 ;
26578 wxDataFormat *result;
26579 bool temp1 = false ;
26580 PyObject * obj0 = 0 ;
26581 char *kwnames[] = {
26582 (char *) "format", NULL
26583 };
26584
26585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26586 {
26587 arg1 = wxString_in_helper(obj0);
26588 if (arg1 == NULL) SWIG_fail;
26589 temp1 = true;
26590 }
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26599 {
26600 if (temp1)
26601 delete arg1;
26602 }
26603 return resultobj;
26604 fail:
26605 {
26606 if (temp1)
26607 delete arg1;
26608 }
26609 return NULL;
26610 }
26611
26612
26613 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26614 PyObject *resultobj;
26615 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26616 PyObject * obj0 = 0 ;
26617 char *kwnames[] = {
26618 (char *) "self", NULL
26619 };
26620
26621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26623 if (SWIG_arg_fail(1)) SWIG_fail;
26624 {
26625 PyThreadState* __tstate = wxPyBeginAllowThreads();
26626 delete arg1;
26627
26628 wxPyEndAllowThreads(__tstate);
26629 if (PyErr_Occurred()) SWIG_fail;
26630 }
26631 Py_INCREF(Py_None); resultobj = Py_None;
26632 return resultobj;
26633 fail:
26634 return NULL;
26635 }
26636
26637
26638 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26639 PyObject *resultobj;
26640 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26641 wxDataFormatId arg2 ;
26642 bool result;
26643 PyObject * obj0 = 0 ;
26644 PyObject * obj1 = 0 ;
26645
26646 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26648 if (SWIG_arg_fail(1)) SWIG_fail;
26649 {
26650 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26651 if (SWIG_arg_fail(2)) SWIG_fail;
26652 }
26653 {
26654 PyThreadState* __tstate = wxPyBeginAllowThreads();
26655 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26656
26657 wxPyEndAllowThreads(__tstate);
26658 if (PyErr_Occurred()) SWIG_fail;
26659 }
26660 {
26661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26662 }
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26670 PyObject *resultobj;
26671 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26672 wxDataFormatId arg2 ;
26673 bool result;
26674 PyObject * obj0 = 0 ;
26675 PyObject * obj1 = 0 ;
26676
26677 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26679 if (SWIG_arg_fail(1)) SWIG_fail;
26680 {
26681 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26682 if (SWIG_arg_fail(2)) SWIG_fail;
26683 }
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26687
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 {
26692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26693 }
26694 return resultobj;
26695 fail:
26696 return NULL;
26697 }
26698
26699
26700 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26701 PyObject *resultobj;
26702 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26703 wxDataFormat *arg2 = 0 ;
26704 bool result;
26705 PyObject * obj0 = 0 ;
26706 PyObject * obj1 = 0 ;
26707
26708 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26710 if (SWIG_arg_fail(1)) SWIG_fail;
26711 {
26712 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26713 if (SWIG_arg_fail(2)) SWIG_fail;
26714 if (arg2 == NULL) {
26715 SWIG_null_ref("wxDataFormat");
26716 }
26717 if (SWIG_arg_fail(2)) SWIG_fail;
26718 }
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26722
26723 wxPyEndAllowThreads(__tstate);
26724 if (PyErr_Occurred()) SWIG_fail;
26725 }
26726 {
26727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26728 }
26729 return resultobj;
26730 fail:
26731 return NULL;
26732 }
26733
26734
26735 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26736 int argc;
26737 PyObject *argv[3];
26738 int ii;
26739
26740 argc = PyObject_Length(args);
26741 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26742 argv[ii] = PyTuple_GetItem(args,ii);
26743 }
26744 if (argc == 2) {
26745 int _v;
26746 {
26747 void *ptr;
26748 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26749 _v = 0;
26750 PyErr_Clear();
26751 } else {
26752 _v = 1;
26753 }
26754 }
26755 if (_v) {
26756 {
26757 void *ptr = 0;
26758 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26759 _v = 0;
26760 PyErr_Clear();
26761 } else {
26762 _v = (ptr != 0);
26763 }
26764 }
26765 if (_v) {
26766 return _wrap_DataFormat___eq____SWIG_1(self,args);
26767 }
26768 }
26769 }
26770 if (argc == 2) {
26771 int _v;
26772 {
26773 void *ptr;
26774 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26775 _v = 0;
26776 PyErr_Clear();
26777 } else {
26778 _v = 1;
26779 }
26780 }
26781 if (_v) {
26782 _v = SWIG_Check_int(argv[1]);
26783 if (_v) {
26784 return _wrap_DataFormat___eq____SWIG_0(self,args);
26785 }
26786 }
26787 }
26788
26789 Py_INCREF(Py_NotImplemented);
26790 return Py_NotImplemented;
26791 }
26792
26793
26794 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26795 PyObject *resultobj;
26796 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26797 wxDataFormat *arg2 = 0 ;
26798 bool result;
26799 PyObject * obj0 = 0 ;
26800 PyObject * obj1 = 0 ;
26801
26802 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26804 if (SWIG_arg_fail(1)) SWIG_fail;
26805 {
26806 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26807 if (SWIG_arg_fail(2)) SWIG_fail;
26808 if (arg2 == NULL) {
26809 SWIG_null_ref("wxDataFormat");
26810 }
26811 if (SWIG_arg_fail(2)) SWIG_fail;
26812 }
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 {
26821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26822 }
26823 return resultobj;
26824 fail:
26825 return NULL;
26826 }
26827
26828
26829 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26830 int argc;
26831 PyObject *argv[3];
26832 int ii;
26833
26834 argc = PyObject_Length(args);
26835 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26836 argv[ii] = PyTuple_GetItem(args,ii);
26837 }
26838 if (argc == 2) {
26839 int _v;
26840 {
26841 void *ptr;
26842 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26843 _v = 0;
26844 PyErr_Clear();
26845 } else {
26846 _v = 1;
26847 }
26848 }
26849 if (_v) {
26850 {
26851 void *ptr = 0;
26852 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26853 _v = 0;
26854 PyErr_Clear();
26855 } else {
26856 _v = (ptr != 0);
26857 }
26858 }
26859 if (_v) {
26860 return _wrap_DataFormat___ne____SWIG_1(self,args);
26861 }
26862 }
26863 }
26864 if (argc == 2) {
26865 int _v;
26866 {
26867 void *ptr;
26868 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26869 _v = 0;
26870 PyErr_Clear();
26871 } else {
26872 _v = 1;
26873 }
26874 }
26875 if (_v) {
26876 _v = SWIG_Check_int(argv[1]);
26877 if (_v) {
26878 return _wrap_DataFormat___ne____SWIG_0(self,args);
26879 }
26880 }
26881 }
26882
26883 Py_INCREF(Py_NotImplemented);
26884 return Py_NotImplemented;
26885 }
26886
26887
26888 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26889 PyObject *resultobj;
26890 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26891 wxDataFormatId arg2 ;
26892 PyObject * obj0 = 0 ;
26893 PyObject * obj1 = 0 ;
26894 char *kwnames[] = {
26895 (char *) "self",(char *) "format", NULL
26896 };
26897
26898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26900 if (SWIG_arg_fail(1)) SWIG_fail;
26901 {
26902 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26903 if (SWIG_arg_fail(2)) SWIG_fail;
26904 }
26905 {
26906 PyThreadState* __tstate = wxPyBeginAllowThreads();
26907 (arg1)->SetType((wxDataFormatId )arg2);
26908
26909 wxPyEndAllowThreads(__tstate);
26910 if (PyErr_Occurred()) SWIG_fail;
26911 }
26912 Py_INCREF(Py_None); resultobj = Py_None;
26913 return resultobj;
26914 fail:
26915 return NULL;
26916 }
26917
26918
26919 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26920 PyObject *resultobj;
26921 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26922 wxDataFormatId result;
26923 PyObject * obj0 = 0 ;
26924 char *kwnames[] = {
26925 (char *) "self", NULL
26926 };
26927
26928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26930 if (SWIG_arg_fail(1)) SWIG_fail;
26931 {
26932 PyThreadState* __tstate = wxPyBeginAllowThreads();
26933 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26934
26935 wxPyEndAllowThreads(__tstate);
26936 if (PyErr_Occurred()) SWIG_fail;
26937 }
26938 resultobj = SWIG_From_int((result));
26939 return resultobj;
26940 fail:
26941 return NULL;
26942 }
26943
26944
26945 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26946 PyObject *resultobj;
26947 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26948 wxString result;
26949 PyObject * obj0 = 0 ;
26950 char *kwnames[] = {
26951 (char *) "self", NULL
26952 };
26953
26954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26956 if (SWIG_arg_fail(1)) SWIG_fail;
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = ((wxDataFormat const *)arg1)->GetId();
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 {
26965 #if wxUSE_UNICODE
26966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26967 #else
26968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26969 #endif
26970 }
26971 return resultobj;
26972 fail:
26973 return NULL;
26974 }
26975
26976
26977 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26978 PyObject *resultobj;
26979 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26980 wxString *arg2 = 0 ;
26981 bool temp2 = false ;
26982 PyObject * obj0 = 0 ;
26983 PyObject * obj1 = 0 ;
26984 char *kwnames[] = {
26985 (char *) "self",(char *) "format", NULL
26986 };
26987
26988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26990 if (SWIG_arg_fail(1)) SWIG_fail;
26991 {
26992 arg2 = wxString_in_helper(obj1);
26993 if (arg2 == NULL) SWIG_fail;
26994 temp2 = true;
26995 }
26996 {
26997 PyThreadState* __tstate = wxPyBeginAllowThreads();
26998 (arg1)->SetId((wxString const &)*arg2);
26999
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 Py_INCREF(Py_None); resultobj = Py_None;
27004 {
27005 if (temp2)
27006 delete arg2;
27007 }
27008 return resultobj;
27009 fail:
27010 {
27011 if (temp2)
27012 delete arg2;
27013 }
27014 return NULL;
27015 }
27016
27017
27018 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
27019 PyObject *obj;
27020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27021 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
27022 Py_INCREF(obj);
27023 return Py_BuildValue((char *)"");
27024 }
27025 static int _wrap_FormatInvalid_set(PyObject *) {
27026 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
27027 return 1;
27028 }
27029
27030
27031 static PyObject *_wrap_FormatInvalid_get(void) {
27032 PyObject *pyobj;
27033
27034 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
27035 return pyobj;
27036 }
27037
27038
27039 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27040 PyObject *resultobj;
27041 wxDataObject *arg1 = (wxDataObject *) 0 ;
27042 PyObject * obj0 = 0 ;
27043 char *kwnames[] = {
27044 (char *) "self", NULL
27045 };
27046
27047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27049 if (SWIG_arg_fail(1)) SWIG_fail;
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 delete arg1;
27053
27054 wxPyEndAllowThreads(__tstate);
27055 if (PyErr_Occurred()) SWIG_fail;
27056 }
27057 Py_INCREF(Py_None); resultobj = Py_None;
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj;
27066 wxDataObject *arg1 = (wxDataObject *) 0 ;
27067 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27068 SwigValueWrapper<wxDataFormat > result;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "dir", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 if (obj1) {
27079 {
27080 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27081 if (SWIG_arg_fail(2)) SWIG_fail;
27082 }
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 {
27092 wxDataFormat * resultptr;
27093 resultptr = new wxDataFormat((wxDataFormat &)(result));
27094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27095 }
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27103 PyObject *resultobj;
27104 wxDataObject *arg1 = (wxDataObject *) 0 ;
27105 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27106 size_t result;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char *kwnames[] = {
27110 (char *) "self",(char *) "dir", NULL
27111 };
27112
27113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27115 if (SWIG_arg_fail(1)) SWIG_fail;
27116 if (obj1) {
27117 {
27118 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27119 if (SWIG_arg_fail(2)) SWIG_fail;
27120 }
27121 }
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27125
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 {
27130 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27131 }
27132 return resultobj;
27133 fail:
27134 return NULL;
27135 }
27136
27137
27138 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27139 PyObject *resultobj;
27140 wxDataObject *arg1 = (wxDataObject *) 0 ;
27141 wxDataFormat *arg2 = 0 ;
27142 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27143 bool result;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 PyObject * obj2 = 0 ;
27147 char *kwnames[] = {
27148 (char *) "self",(char *) "format",(char *) "dir", NULL
27149 };
27150
27151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27153 if (SWIG_arg_fail(1)) SWIG_fail;
27154 {
27155 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27156 if (SWIG_arg_fail(2)) SWIG_fail;
27157 if (arg2 == NULL) {
27158 SWIG_null_ref("wxDataFormat");
27159 }
27160 if (SWIG_arg_fail(2)) SWIG_fail;
27161 }
27162 if (obj2) {
27163 {
27164 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27165 if (SWIG_arg_fail(3)) SWIG_fail;
27166 }
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxDataObject *arg1 = (wxDataObject *) 0 ;
27187 wxDataFormat *arg2 = 0 ;
27188 size_t result;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char *kwnames[] = {
27192 (char *) "self",(char *) "format", NULL
27193 };
27194
27195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27197 if (SWIG_arg_fail(1)) SWIG_fail;
27198 {
27199 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27200 if (SWIG_arg_fail(2)) SWIG_fail;
27201 if (arg2 == NULL) {
27202 SWIG_null_ref("wxDataFormat");
27203 }
27204 if (SWIG_arg_fail(2)) SWIG_fail;
27205 }
27206 {
27207 PyThreadState* __tstate = wxPyBeginAllowThreads();
27208 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27209
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 {
27214 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27215 }
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27223 PyObject *resultobj;
27224 wxDataObject *arg1 = (wxDataObject *) 0 ;
27225 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27226 PyObject *result;
27227 PyObject * obj0 = 0 ;
27228 PyObject * obj1 = 0 ;
27229 char *kwnames[] = {
27230 (char *) "self",(char *) "dir", NULL
27231 };
27232
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 if (obj1) {
27237 {
27238 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27239 if (SWIG_arg_fail(2)) SWIG_fail;
27240 }
27241 }
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27245
27246 wxPyEndAllowThreads(__tstate);
27247 if (PyErr_Occurred()) SWIG_fail;
27248 }
27249 resultobj = result;
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxDataObject *arg1 = (wxDataObject *) 0 ;
27259 wxDataFormat *arg2 = 0 ;
27260 PyObject *result;
27261 PyObject * obj0 = 0 ;
27262 PyObject * obj1 = 0 ;
27263 char *kwnames[] = {
27264 (char *) "self",(char *) "format", NULL
27265 };
27266
27267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27269 if (SWIG_arg_fail(1)) SWIG_fail;
27270 {
27271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27272 if (SWIG_arg_fail(2)) SWIG_fail;
27273 if (arg2 == NULL) {
27274 SWIG_null_ref("wxDataFormat");
27275 }
27276 if (SWIG_arg_fail(2)) SWIG_fail;
27277 }
27278 {
27279 PyThreadState* __tstate = wxPyBeginAllowThreads();
27280 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27281
27282 wxPyEndAllowThreads(__tstate);
27283 if (PyErr_Occurred()) SWIG_fail;
27284 }
27285 resultobj = result;
27286 return resultobj;
27287 fail:
27288 return NULL;
27289 }
27290
27291
27292 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27293 PyObject *resultobj;
27294 wxDataObject *arg1 = (wxDataObject *) 0 ;
27295 wxDataFormat *arg2 = 0 ;
27296 PyObject *arg3 = (PyObject *) 0 ;
27297 bool result;
27298 PyObject * obj0 = 0 ;
27299 PyObject * obj1 = 0 ;
27300 PyObject * obj2 = 0 ;
27301 char *kwnames[] = {
27302 (char *) "self",(char *) "format",(char *) "data", NULL
27303 };
27304
27305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27307 if (SWIG_arg_fail(1)) SWIG_fail;
27308 {
27309 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27310 if (SWIG_arg_fail(2)) SWIG_fail;
27311 if (arg2 == NULL) {
27312 SWIG_null_ref("wxDataFormat");
27313 }
27314 if (SWIG_arg_fail(2)) SWIG_fail;
27315 }
27316 arg3 = obj2;
27317 {
27318 PyThreadState* __tstate = wxPyBeginAllowThreads();
27319 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27320
27321 wxPyEndAllowThreads(__tstate);
27322 if (PyErr_Occurred()) SWIG_fail;
27323 }
27324 {
27325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27326 }
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27334 PyObject *obj;
27335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27336 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27337 Py_INCREF(obj);
27338 return Py_BuildValue((char *)"");
27339 }
27340 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27341 PyObject *resultobj;
27342 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27343 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27344 wxDataObjectSimple *result;
27345 PyObject * obj0 = 0 ;
27346 char *kwnames[] = {
27347 (char *) "format", NULL
27348 };
27349
27350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27351 if (obj0) {
27352 {
27353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27354 if (SWIG_arg_fail(1)) SWIG_fail;
27355 if (arg1 == NULL) {
27356 SWIG_null_ref("wxDataFormat");
27357 }
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 }
27360 }
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27364
27365 wxPyEndAllowThreads(__tstate);
27366 if (PyErr_Occurred()) SWIG_fail;
27367 }
27368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj;
27377 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27378 wxDataFormat *result;
27379 PyObject * obj0 = 0 ;
27380 char *kwnames[] = {
27381 (char *) "self", NULL
27382 };
27383
27384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27386 if (SWIG_arg_fail(1)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 {
27390 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27391 result = (wxDataFormat *) &_result_ref;
27392 }
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27405 PyObject *resultobj;
27406 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27407 wxDataFormat *arg2 = 0 ;
27408 PyObject * obj0 = 0 ;
27409 PyObject * obj1 = 0 ;
27410 char *kwnames[] = {
27411 (char *) "self",(char *) "format", NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27416 if (SWIG_arg_fail(1)) SWIG_fail;
27417 {
27418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27419 if (SWIG_arg_fail(2)) SWIG_fail;
27420 if (arg2 == NULL) {
27421 SWIG_null_ref("wxDataFormat");
27422 }
27423 if (SWIG_arg_fail(2)) SWIG_fail;
27424 }
27425 {
27426 PyThreadState* __tstate = wxPyBeginAllowThreads();
27427 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27428
27429 wxPyEndAllowThreads(__tstate);
27430 if (PyErr_Occurred()) SWIG_fail;
27431 }
27432 Py_INCREF(Py_None); resultobj = Py_None;
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27440 PyObject *resultobj;
27441 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27442 size_t result;
27443 PyObject * obj0 = 0 ;
27444 char *kwnames[] = {
27445 (char *) "self", NULL
27446 };
27447
27448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27450 if (SWIG_arg_fail(1)) SWIG_fail;
27451 {
27452 PyThreadState* __tstate = wxPyBeginAllowThreads();
27453 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27454
27455 wxPyEndAllowThreads(__tstate);
27456 if (PyErr_Occurred()) SWIG_fail;
27457 }
27458 {
27459 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27460 }
27461 return resultobj;
27462 fail:
27463 return NULL;
27464 }
27465
27466
27467 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27468 PyObject *resultobj;
27469 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27470 PyObject *result;
27471 PyObject * obj0 = 0 ;
27472 char *kwnames[] = {
27473 (char *) "self", NULL
27474 };
27475
27476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27478 if (SWIG_arg_fail(1)) SWIG_fail;
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 resultobj = result;
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj;
27495 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27496 PyObject *arg2 = (PyObject *) 0 ;
27497 bool result;
27498 PyObject * obj0 = 0 ;
27499 PyObject * obj1 = 0 ;
27500 char *kwnames[] = {
27501 (char *) "self",(char *) "data", NULL
27502 };
27503
27504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27506 if (SWIG_arg_fail(1)) SWIG_fail;
27507 arg2 = obj1;
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27511
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 {
27516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27517 }
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27525 PyObject *obj;
27526 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27527 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27528 Py_INCREF(obj);
27529 return Py_BuildValue((char *)"");
27530 }
27531 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27532 PyObject *resultobj;
27533 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27534 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27535 wxPyDataObjectSimple *result;
27536 PyObject * obj0 = 0 ;
27537 char *kwnames[] = {
27538 (char *) "format", NULL
27539 };
27540
27541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27542 if (obj0) {
27543 {
27544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27545 if (SWIG_arg_fail(1)) SWIG_fail;
27546 if (arg1 == NULL) {
27547 SWIG_null_ref("wxDataFormat");
27548 }
27549 if (SWIG_arg_fail(1)) SWIG_fail;
27550 }
27551 }
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27555
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27560 return resultobj;
27561 fail:
27562 return NULL;
27563 }
27564
27565
27566 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27567 PyObject *resultobj;
27568 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27569 PyObject *arg2 = (PyObject *) 0 ;
27570 PyObject *arg3 = (PyObject *) 0 ;
27571 PyObject * obj0 = 0 ;
27572 PyObject * obj1 = 0 ;
27573 PyObject * obj2 = 0 ;
27574 char *kwnames[] = {
27575 (char *) "self",(char *) "self",(char *) "_class", NULL
27576 };
27577
27578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27580 if (SWIG_arg_fail(1)) SWIG_fail;
27581 arg2 = obj1;
27582 arg3 = obj2;
27583 {
27584 PyThreadState* __tstate = wxPyBeginAllowThreads();
27585 (arg1)->_setCallbackInfo(arg2,arg3);
27586
27587 wxPyEndAllowThreads(__tstate);
27588 if (PyErr_Occurred()) SWIG_fail;
27589 }
27590 Py_INCREF(Py_None); resultobj = Py_None;
27591 return resultobj;
27592 fail:
27593 return NULL;
27594 }
27595
27596
27597 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27598 PyObject *obj;
27599 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27600 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27601 Py_INCREF(obj);
27602 return Py_BuildValue((char *)"");
27603 }
27604 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27605 PyObject *resultobj;
27606 wxDataObjectComposite *result;
27607 char *kwnames[] = {
27608 NULL
27609 };
27610
27611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27612 {
27613 PyThreadState* __tstate = wxPyBeginAllowThreads();
27614 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27615
27616 wxPyEndAllowThreads(__tstate);
27617 if (PyErr_Occurred()) SWIG_fail;
27618 }
27619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27620 return resultobj;
27621 fail:
27622 return NULL;
27623 }
27624
27625
27626 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27627 PyObject *resultobj;
27628 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27629 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27630 bool arg3 = (bool) false ;
27631 PyObject * obj0 = 0 ;
27632 PyObject * obj1 = 0 ;
27633 PyObject * obj2 = 0 ;
27634 char *kwnames[] = {
27635 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27636 };
27637
27638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27640 if (SWIG_arg_fail(1)) SWIG_fail;
27641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27642 if (SWIG_arg_fail(2)) SWIG_fail;
27643 if (obj2) {
27644 {
27645 arg3 = (bool)(SWIG_As_bool(obj2));
27646 if (SWIG_arg_fail(3)) SWIG_fail;
27647 }
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 (arg1)->Add(arg2,arg3);
27652
27653 wxPyEndAllowThreads(__tstate);
27654 if (PyErr_Occurred()) SWIG_fail;
27655 }
27656 Py_INCREF(Py_None); resultobj = Py_None;
27657 return resultobj;
27658 fail:
27659 return NULL;
27660 }
27661
27662
27663 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27664 PyObject *obj;
27665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27666 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27667 Py_INCREF(obj);
27668 return Py_BuildValue((char *)"");
27669 }
27670 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27671 PyObject *resultobj;
27672 wxString const &arg1_defvalue = wxPyEmptyString ;
27673 wxString *arg1 = (wxString *) &arg1_defvalue ;
27674 wxTextDataObject *result;
27675 bool temp1 = false ;
27676 PyObject * obj0 = 0 ;
27677 char *kwnames[] = {
27678 (char *) "text", NULL
27679 };
27680
27681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27682 if (obj0) {
27683 {
27684 arg1 = wxString_in_helper(obj0);
27685 if (arg1 == NULL) SWIG_fail;
27686 temp1 = true;
27687 }
27688 }
27689 {
27690 PyThreadState* __tstate = wxPyBeginAllowThreads();
27691 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27692
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27697 {
27698 if (temp1)
27699 delete arg1;
27700 }
27701 return resultobj;
27702 fail:
27703 {
27704 if (temp1)
27705 delete arg1;
27706 }
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj;
27713 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27714 size_t result;
27715 PyObject * obj0 = 0 ;
27716 char *kwnames[] = {
27717 (char *) "self", NULL
27718 };
27719
27720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27722 if (SWIG_arg_fail(1)) SWIG_fail;
27723 {
27724 PyThreadState* __tstate = wxPyBeginAllowThreads();
27725 result = (size_t)(arg1)->GetTextLength();
27726
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 {
27731 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27732 }
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27740 PyObject *resultobj;
27741 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27742 wxString result;
27743 PyObject * obj0 = 0 ;
27744 char *kwnames[] = {
27745 (char *) "self", NULL
27746 };
27747
27748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27750 if (SWIG_arg_fail(1)) SWIG_fail;
27751 {
27752 PyThreadState* __tstate = wxPyBeginAllowThreads();
27753 result = (arg1)->GetText();
27754
27755 wxPyEndAllowThreads(__tstate);
27756 if (PyErr_Occurred()) SWIG_fail;
27757 }
27758 {
27759 #if wxUSE_UNICODE
27760 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27761 #else
27762 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27763 #endif
27764 }
27765 return resultobj;
27766 fail:
27767 return NULL;
27768 }
27769
27770
27771 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27772 PyObject *resultobj;
27773 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27774 wxString *arg2 = 0 ;
27775 bool temp2 = false ;
27776 PyObject * obj0 = 0 ;
27777 PyObject * obj1 = 0 ;
27778 char *kwnames[] = {
27779 (char *) "self",(char *) "text", NULL
27780 };
27781
27782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27784 if (SWIG_arg_fail(1)) SWIG_fail;
27785 {
27786 arg2 = wxString_in_helper(obj1);
27787 if (arg2 == NULL) SWIG_fail;
27788 temp2 = true;
27789 }
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 (arg1)->SetText((wxString const &)*arg2);
27793
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 Py_INCREF(Py_None); resultobj = Py_None;
27798 {
27799 if (temp2)
27800 delete arg2;
27801 }
27802 return resultobj;
27803 fail:
27804 {
27805 if (temp2)
27806 delete arg2;
27807 }
27808 return NULL;
27809 }
27810
27811
27812 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27813 PyObject *obj;
27814 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27815 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27816 Py_INCREF(obj);
27817 return Py_BuildValue((char *)"");
27818 }
27819 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27820 PyObject *resultobj;
27821 wxString const &arg1_defvalue = wxPyEmptyString ;
27822 wxString *arg1 = (wxString *) &arg1_defvalue ;
27823 wxPyTextDataObject *result;
27824 bool temp1 = false ;
27825 PyObject * obj0 = 0 ;
27826 char *kwnames[] = {
27827 (char *) "text", NULL
27828 };
27829
27830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27831 if (obj0) {
27832 {
27833 arg1 = wxString_in_helper(obj0);
27834 if (arg1 == NULL) SWIG_fail;
27835 temp1 = true;
27836 }
27837 }
27838 {
27839 PyThreadState* __tstate = wxPyBeginAllowThreads();
27840 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27841
27842 wxPyEndAllowThreads(__tstate);
27843 if (PyErr_Occurred()) SWIG_fail;
27844 }
27845 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27846 {
27847 if (temp1)
27848 delete arg1;
27849 }
27850 return resultobj;
27851 fail:
27852 {
27853 if (temp1)
27854 delete arg1;
27855 }
27856 return NULL;
27857 }
27858
27859
27860 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27861 PyObject *resultobj;
27862 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27863 PyObject *arg2 = (PyObject *) 0 ;
27864 PyObject *arg3 = (PyObject *) 0 ;
27865 PyObject * obj0 = 0 ;
27866 PyObject * obj1 = 0 ;
27867 PyObject * obj2 = 0 ;
27868 char *kwnames[] = {
27869 (char *) "self",(char *) "self",(char *) "_class", NULL
27870 };
27871
27872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27874 if (SWIG_arg_fail(1)) SWIG_fail;
27875 arg2 = obj1;
27876 arg3 = obj2;
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 (arg1)->_setCallbackInfo(arg2,arg3);
27880
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 Py_INCREF(Py_None); resultobj = Py_None;
27885 return resultobj;
27886 fail:
27887 return NULL;
27888 }
27889
27890
27891 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27892 PyObject *obj;
27893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27894 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27895 Py_INCREF(obj);
27896 return Py_BuildValue((char *)"");
27897 }
27898 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27899 PyObject *resultobj;
27900 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27901 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27902 wxBitmapDataObject *result;
27903 PyObject * obj0 = 0 ;
27904 char *kwnames[] = {
27905 (char *) "bitmap", NULL
27906 };
27907
27908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27909 if (obj0) {
27910 {
27911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27912 if (SWIG_arg_fail(1)) SWIG_fail;
27913 if (arg1 == NULL) {
27914 SWIG_null_ref("wxBitmap");
27915 }
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 }
27918 }
27919 {
27920 PyThreadState* __tstate = wxPyBeginAllowThreads();
27921 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27922
27923 wxPyEndAllowThreads(__tstate);
27924 if (PyErr_Occurred()) SWIG_fail;
27925 }
27926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj;
27935 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27936 wxBitmap result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 wxBitmap * resultptr;
27954 resultptr = new wxBitmap((wxBitmap &)(result));
27955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27956 }
27957 return resultobj;
27958 fail:
27959 return NULL;
27960 }
27961
27962
27963 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27964 PyObject *resultobj;
27965 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27966 wxBitmap *arg2 = 0 ;
27967 PyObject * obj0 = 0 ;
27968 PyObject * obj1 = 0 ;
27969 char *kwnames[] = {
27970 (char *) "self",(char *) "bitmap", NULL
27971 };
27972
27973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27975 if (SWIG_arg_fail(1)) SWIG_fail;
27976 {
27977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(2)) SWIG_fail;
27979 if (arg2 == NULL) {
27980 SWIG_null_ref("wxBitmap");
27981 }
27982 if (SWIG_arg_fail(2)) SWIG_fail;
27983 }
27984 {
27985 PyThreadState* __tstate = wxPyBeginAllowThreads();
27986 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27987
27988 wxPyEndAllowThreads(__tstate);
27989 if (PyErr_Occurred()) SWIG_fail;
27990 }
27991 Py_INCREF(Py_None); resultobj = Py_None;
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27999 PyObject *obj;
28000 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28001 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
28002 Py_INCREF(obj);
28003 return Py_BuildValue((char *)"");
28004 }
28005 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj;
28007 wxBitmap const &arg1_defvalue = wxNullBitmap ;
28008 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
28009 wxPyBitmapDataObject *result;
28010 PyObject * obj0 = 0 ;
28011 char *kwnames[] = {
28012 (char *) "bitmap", NULL
28013 };
28014
28015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
28016 if (obj0) {
28017 {
28018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
28019 if (SWIG_arg_fail(1)) SWIG_fail;
28020 if (arg1 == NULL) {
28021 SWIG_null_ref("wxBitmap");
28022 }
28023 if (SWIG_arg_fail(1)) SWIG_fail;
28024 }
28025 }
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
28029
28030 wxPyEndAllowThreads(__tstate);
28031 if (PyErr_Occurred()) SWIG_fail;
28032 }
28033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
28034 return resultobj;
28035 fail:
28036 return NULL;
28037 }
28038
28039
28040 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28041 PyObject *resultobj;
28042 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28043 PyObject *arg2 = (PyObject *) 0 ;
28044 PyObject *arg3 = (PyObject *) 0 ;
28045 PyObject * obj0 = 0 ;
28046 PyObject * obj1 = 0 ;
28047 PyObject * obj2 = 0 ;
28048 char *kwnames[] = {
28049 (char *) "self",(char *) "self",(char *) "_class", NULL
28050 };
28051
28052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28054 if (SWIG_arg_fail(1)) SWIG_fail;
28055 arg2 = obj1;
28056 arg3 = obj2;
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 (arg1)->_setCallbackInfo(arg2,arg3);
28060
28061 wxPyEndAllowThreads(__tstate);
28062 if (PyErr_Occurred()) SWIG_fail;
28063 }
28064 Py_INCREF(Py_None); resultobj = Py_None;
28065 return resultobj;
28066 fail:
28067 return NULL;
28068 }
28069
28070
28071 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28072 PyObject *obj;
28073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28074 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28075 Py_INCREF(obj);
28076 return Py_BuildValue((char *)"");
28077 }
28078 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28079 PyObject *resultobj;
28080 wxFileDataObject *result;
28081 char *kwnames[] = {
28082 NULL
28083 };
28084
28085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28086 {
28087 PyThreadState* __tstate = wxPyBeginAllowThreads();
28088 result = (wxFileDataObject *)new wxFileDataObject();
28089
28090 wxPyEndAllowThreads(__tstate);
28091 if (PyErr_Occurred()) SWIG_fail;
28092 }
28093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28094 return resultobj;
28095 fail:
28096 return NULL;
28097 }
28098
28099
28100 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj;
28102 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28103 wxArrayString *result;
28104 PyObject * obj0 = 0 ;
28105 char *kwnames[] = {
28106 (char *) "self", NULL
28107 };
28108
28109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28111 if (SWIG_arg_fail(1)) SWIG_fail;
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 {
28115 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28116 result = (wxArrayString *) &_result_ref;
28117 }
28118
28119 wxPyEndAllowThreads(__tstate);
28120 if (PyErr_Occurred()) SWIG_fail;
28121 }
28122 {
28123 resultobj = wxArrayString2PyList_helper(*result);
28124 }
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28132 PyObject *resultobj;
28133 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28134 wxString *arg2 = 0 ;
28135 bool temp2 = false ;
28136 PyObject * obj0 = 0 ;
28137 PyObject * obj1 = 0 ;
28138 char *kwnames[] = {
28139 (char *) "self",(char *) "filename", NULL
28140 };
28141
28142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28144 if (SWIG_arg_fail(1)) SWIG_fail;
28145 {
28146 arg2 = wxString_in_helper(obj1);
28147 if (arg2 == NULL) SWIG_fail;
28148 temp2 = true;
28149 }
28150 {
28151 PyThreadState* __tstate = wxPyBeginAllowThreads();
28152 (arg1)->AddFile((wxString const &)*arg2);
28153
28154 wxPyEndAllowThreads(__tstate);
28155 if (PyErr_Occurred()) SWIG_fail;
28156 }
28157 Py_INCREF(Py_None); resultobj = Py_None;
28158 {
28159 if (temp2)
28160 delete arg2;
28161 }
28162 return resultobj;
28163 fail:
28164 {
28165 if (temp2)
28166 delete arg2;
28167 }
28168 return NULL;
28169 }
28170
28171
28172 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28173 PyObject *obj;
28174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28175 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28176 Py_INCREF(obj);
28177 return Py_BuildValue((char *)"");
28178 }
28179 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28180 PyObject *resultobj;
28181 wxDataFormat *arg1 = 0 ;
28182 wxCustomDataObject *result;
28183 PyObject * obj0 = 0 ;
28184
28185 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28186 {
28187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28188 if (SWIG_arg_fail(1)) SWIG_fail;
28189 if (arg1 == NULL) {
28190 SWIG_null_ref("wxDataFormat");
28191 }
28192 if (SWIG_arg_fail(1)) SWIG_fail;
28193 }
28194 {
28195 PyThreadState* __tstate = wxPyBeginAllowThreads();
28196 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28197
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28209 PyObject *resultobj;
28210 wxString *arg1 = 0 ;
28211 wxCustomDataObject *result;
28212 bool temp1 = false ;
28213 PyObject * obj0 = 0 ;
28214
28215 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28216 {
28217 arg1 = wxString_in_helper(obj0);
28218 if (arg1 == NULL) SWIG_fail;
28219 temp1 = true;
28220 }
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28224
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28229 {
28230 if (temp1)
28231 delete arg1;
28232 }
28233 return resultobj;
28234 fail:
28235 {
28236 if (temp1)
28237 delete arg1;
28238 }
28239 return NULL;
28240 }
28241
28242
28243 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28244 PyObject *resultobj;
28245 wxCustomDataObject *result;
28246
28247 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 result = (wxCustomDataObject *)new wxCustomDataObject();
28251
28252 wxPyEndAllowThreads(__tstate);
28253 if (PyErr_Occurred()) SWIG_fail;
28254 }
28255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28263 int argc;
28264 PyObject *argv[2];
28265 int ii;
28266
28267 argc = PyObject_Length(args);
28268 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28269 argv[ii] = PyTuple_GetItem(args,ii);
28270 }
28271 if (argc == 0) {
28272 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28273 }
28274 if (argc == 1) {
28275 int _v;
28276 {
28277 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28278 }
28279 if (_v) {
28280 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28281 }
28282 }
28283 if (argc == 1) {
28284 int _v;
28285 {
28286 void *ptr = 0;
28287 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28288 _v = 0;
28289 PyErr_Clear();
28290 } else {
28291 _v = (ptr != 0);
28292 }
28293 }
28294 if (_v) {
28295 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28296 }
28297 }
28298
28299 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28300 return NULL;
28301 }
28302
28303
28304 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj;
28306 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28307 PyObject *arg2 = (PyObject *) 0 ;
28308 bool result;
28309 PyObject * obj0 = 0 ;
28310 PyObject * obj1 = 0 ;
28311 char *kwnames[] = {
28312 (char *) "self",(char *) "data", NULL
28313 };
28314
28315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28317 if (SWIG_arg_fail(1)) SWIG_fail;
28318 arg2 = obj1;
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28322
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 {
28327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28328 }
28329 return resultobj;
28330 fail:
28331 return NULL;
28332 }
28333
28334
28335 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28336 PyObject *resultobj;
28337 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28338 size_t result;
28339 PyObject * obj0 = 0 ;
28340 char *kwnames[] = {
28341 (char *) "self", NULL
28342 };
28343
28344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28346 if (SWIG_arg_fail(1)) SWIG_fail;
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (size_t)(arg1)->GetSize();
28350
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj;
28365 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28366 PyObject *result;
28367 PyObject * obj0 = 0 ;
28368 char *kwnames[] = {
28369 (char *) "self", NULL
28370 };
28371
28372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28374 if (SWIG_arg_fail(1)) SWIG_fail;
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28378
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 resultobj = result;
28383 return resultobj;
28384 fail:
28385 return NULL;
28386 }
28387
28388
28389 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28390 PyObject *obj;
28391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28392 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28393 Py_INCREF(obj);
28394 return Py_BuildValue((char *)"");
28395 }
28396 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28397 PyObject *resultobj;
28398 wxURLDataObject *result;
28399 char *kwnames[] = {
28400 NULL
28401 };
28402
28403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 result = (wxURLDataObject *)new wxURLDataObject();
28407
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj;
28420 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28421 wxString result;
28422 PyObject * obj0 = 0 ;
28423 char *kwnames[] = {
28424 (char *) "self", NULL
28425 };
28426
28427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28429 if (SWIG_arg_fail(1)) SWIG_fail;
28430 {
28431 PyThreadState* __tstate = wxPyBeginAllowThreads();
28432 result = (arg1)->GetURL();
28433
28434 wxPyEndAllowThreads(__tstate);
28435 if (PyErr_Occurred()) SWIG_fail;
28436 }
28437 {
28438 #if wxUSE_UNICODE
28439 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28440 #else
28441 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28442 #endif
28443 }
28444 return resultobj;
28445 fail:
28446 return NULL;
28447 }
28448
28449
28450 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28451 PyObject *resultobj;
28452 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28453 wxString *arg2 = 0 ;
28454 bool temp2 = false ;
28455 PyObject * obj0 = 0 ;
28456 PyObject * obj1 = 0 ;
28457 char *kwnames[] = {
28458 (char *) "self",(char *) "url", NULL
28459 };
28460
28461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28463 if (SWIG_arg_fail(1)) SWIG_fail;
28464 {
28465 arg2 = wxString_in_helper(obj1);
28466 if (arg2 == NULL) SWIG_fail;
28467 temp2 = true;
28468 }
28469 {
28470 PyThreadState* __tstate = wxPyBeginAllowThreads();
28471 (arg1)->SetURL((wxString const &)*arg2);
28472
28473 wxPyEndAllowThreads(__tstate);
28474 if (PyErr_Occurred()) SWIG_fail;
28475 }
28476 Py_INCREF(Py_None); resultobj = Py_None;
28477 {
28478 if (temp2)
28479 delete arg2;
28480 }
28481 return resultobj;
28482 fail:
28483 {
28484 if (temp2)
28485 delete arg2;
28486 }
28487 return NULL;
28488 }
28489
28490
28491 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28492 PyObject *obj;
28493 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28494 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28495 Py_INCREF(obj);
28496 return Py_BuildValue((char *)"");
28497 }
28498 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28499 PyObject *resultobj;
28500 wxMetafileDataObject *result;
28501 char *kwnames[] = {
28502 NULL
28503 };
28504
28505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28506 {
28507 PyThreadState* __tstate = wxPyBeginAllowThreads();
28508 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28509
28510 wxPyEndAllowThreads(__tstate);
28511 if (PyErr_Occurred()) SWIG_fail;
28512 }
28513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28521 PyObject *obj;
28522 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28523 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28524 Py_INCREF(obj);
28525 return Py_BuildValue((char *)"");
28526 }
28527 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28528 PyObject *resultobj;
28529 wxDragResult arg1 ;
28530 bool result;
28531 PyObject * obj0 = 0 ;
28532 char *kwnames[] = {
28533 (char *) "res", NULL
28534 };
28535
28536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28537 {
28538 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28539 if (SWIG_arg_fail(1)) SWIG_fail;
28540 }
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28558 PyObject *resultobj;
28559 wxWindow *arg1 = (wxWindow *) 0 ;
28560 wxIcon const &arg2_defvalue = wxNullIcon ;
28561 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28562 wxIcon const &arg3_defvalue = wxNullIcon ;
28563 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28564 wxIcon const &arg4_defvalue = wxNullIcon ;
28565 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28566 wxPyDropSource *result;
28567 PyObject * obj0 = 0 ;
28568 PyObject * obj1 = 0 ;
28569 PyObject * obj2 = 0 ;
28570 PyObject * obj3 = 0 ;
28571 char *kwnames[] = {
28572 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28573 };
28574
28575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28577 if (SWIG_arg_fail(1)) SWIG_fail;
28578 if (obj1) {
28579 {
28580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(2)) SWIG_fail;
28582 if (arg2 == NULL) {
28583 SWIG_null_ref("wxIcon");
28584 }
28585 if (SWIG_arg_fail(2)) SWIG_fail;
28586 }
28587 }
28588 if (obj2) {
28589 {
28590 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28591 if (SWIG_arg_fail(3)) SWIG_fail;
28592 if (arg3 == NULL) {
28593 SWIG_null_ref("wxIcon");
28594 }
28595 if (SWIG_arg_fail(3)) SWIG_fail;
28596 }
28597 }
28598 if (obj3) {
28599 {
28600 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28601 if (SWIG_arg_fail(4)) SWIG_fail;
28602 if (arg4 == NULL) {
28603 SWIG_null_ref("wxIcon");
28604 }
28605 if (SWIG_arg_fail(4)) SWIG_fail;
28606 }
28607 }
28608 {
28609 PyThreadState* __tstate = wxPyBeginAllowThreads();
28610 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28611
28612 wxPyEndAllowThreads(__tstate);
28613 if (PyErr_Occurred()) SWIG_fail;
28614 }
28615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28616 return resultobj;
28617 fail:
28618 return NULL;
28619 }
28620
28621
28622 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28623 PyObject *resultobj;
28624 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28625 PyObject *arg2 = (PyObject *) 0 ;
28626 PyObject *arg3 = (PyObject *) 0 ;
28627 int arg4 ;
28628 PyObject * obj0 = 0 ;
28629 PyObject * obj1 = 0 ;
28630 PyObject * obj2 = 0 ;
28631 PyObject * obj3 = 0 ;
28632 char *kwnames[] = {
28633 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28634 };
28635
28636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 arg2 = obj1;
28640 arg3 = obj2;
28641 {
28642 arg4 = (int)(SWIG_As_int(obj3));
28643 if (SWIG_arg_fail(4)) SWIG_fail;
28644 }
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28648
28649 wxPyEndAllowThreads(__tstate);
28650 if (PyErr_Occurred()) SWIG_fail;
28651 }
28652 Py_INCREF(Py_None); resultobj = Py_None;
28653 return resultobj;
28654 fail:
28655 return NULL;
28656 }
28657
28658
28659 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28660 PyObject *resultobj;
28661 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28662 PyObject * obj0 = 0 ;
28663 char *kwnames[] = {
28664 (char *) "self", NULL
28665 };
28666
28667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28669 if (SWIG_arg_fail(1)) SWIG_fail;
28670 {
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 delete arg1;
28673
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 Py_INCREF(Py_None); resultobj = Py_None;
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28685 PyObject *resultobj;
28686 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28687 wxDataObject *arg2 = 0 ;
28688 PyObject * obj0 = 0 ;
28689 PyObject * obj1 = 0 ;
28690 char *kwnames[] = {
28691 (char *) "self",(char *) "data", NULL
28692 };
28693
28694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28696 if (SWIG_arg_fail(1)) SWIG_fail;
28697 {
28698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28699 if (SWIG_arg_fail(2)) SWIG_fail;
28700 if (arg2 == NULL) {
28701 SWIG_null_ref("wxDataObject");
28702 }
28703 if (SWIG_arg_fail(2)) SWIG_fail;
28704 }
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 (arg1)->SetData(*arg2);
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 Py_INCREF(Py_None); resultobj = Py_None;
28713 return resultobj;
28714 fail:
28715 return NULL;
28716 }
28717
28718
28719 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28720 PyObject *resultobj;
28721 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28722 wxDataObject *result;
28723 PyObject * obj0 = 0 ;
28724 char *kwnames[] = {
28725 (char *) "self", NULL
28726 };
28727
28728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28730 if (SWIG_arg_fail(1)) SWIG_fail;
28731 {
28732 PyThreadState* __tstate = wxPyBeginAllowThreads();
28733 result = (wxDataObject *)(arg1)->GetDataObject();
28734
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28746 PyObject *resultobj;
28747 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28748 wxDragResult arg2 ;
28749 wxCursor *arg3 = 0 ;
28750 PyObject * obj0 = 0 ;
28751 PyObject * obj1 = 0 ;
28752 PyObject * obj2 = 0 ;
28753 char *kwnames[] = {
28754 (char *) "self",(char *) "res",(char *) "cursor", NULL
28755 };
28756
28757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28759 if (SWIG_arg_fail(1)) SWIG_fail;
28760 {
28761 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28762 if (SWIG_arg_fail(2)) SWIG_fail;
28763 }
28764 {
28765 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28766 if (SWIG_arg_fail(3)) SWIG_fail;
28767 if (arg3 == NULL) {
28768 SWIG_null_ref("wxCursor");
28769 }
28770 if (SWIG_arg_fail(3)) SWIG_fail;
28771 }
28772 {
28773 PyThreadState* __tstate = wxPyBeginAllowThreads();
28774 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28775
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 Py_INCREF(Py_None); resultobj = Py_None;
28780 return resultobj;
28781 fail:
28782 return NULL;
28783 }
28784
28785
28786 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28787 PyObject *resultobj;
28788 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28789 int arg2 = (int) wxDrag_CopyOnly ;
28790 wxDragResult result;
28791 PyObject * obj0 = 0 ;
28792 PyObject * obj1 = 0 ;
28793 char *kwnames[] = {
28794 (char *) "self",(char *) "flags", NULL
28795 };
28796
28797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28799 if (SWIG_arg_fail(1)) SWIG_fail;
28800 if (obj1) {
28801 {
28802 arg2 = (int)(SWIG_As_int(obj1));
28803 if (SWIG_arg_fail(2)) SWIG_fail;
28804 }
28805 }
28806 {
28807 PyThreadState* __tstate = wxPyBeginAllowThreads();
28808 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28809
28810 wxPyEndAllowThreads(__tstate);
28811 if (PyErr_Occurred()) SWIG_fail;
28812 }
28813 resultobj = SWIG_From_int((result));
28814 return resultobj;
28815 fail:
28816 return NULL;
28817 }
28818
28819
28820 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28821 PyObject *resultobj;
28822 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28823 wxDragResult arg2 ;
28824 bool result;
28825 PyObject * obj0 = 0 ;
28826 PyObject * obj1 = 0 ;
28827 char *kwnames[] = {
28828 (char *) "self",(char *) "effect", NULL
28829 };
28830
28831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28833 if (SWIG_arg_fail(1)) SWIG_fail;
28834 {
28835 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28836 if (SWIG_arg_fail(2)) SWIG_fail;
28837 }
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28841
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 {
28846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28847 }
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28855 PyObject *obj;
28856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28857 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28858 Py_INCREF(obj);
28859 return Py_BuildValue((char *)"");
28860 }
28861 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28862 PyObject *resultobj;
28863 wxDataObject *arg1 = (wxDataObject *) NULL ;
28864 wxPyDropTarget *result;
28865 PyObject * obj0 = 0 ;
28866 char *kwnames[] = {
28867 (char *) "dataObject", NULL
28868 };
28869
28870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28871 if (obj0) {
28872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28873 if (SWIG_arg_fail(1)) SWIG_fail;
28874 }
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28878
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28892 PyObject *arg2 = (PyObject *) 0 ;
28893 PyObject *arg3 = (PyObject *) 0 ;
28894 PyObject * obj0 = 0 ;
28895 PyObject * obj1 = 0 ;
28896 PyObject * obj2 = 0 ;
28897 char *kwnames[] = {
28898 (char *) "self",(char *) "self",(char *) "_class", NULL
28899 };
28900
28901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28903 if (SWIG_arg_fail(1)) SWIG_fail;
28904 arg2 = obj1;
28905 arg3 = obj2;
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 (arg1)->_setCallbackInfo(arg2,arg3);
28909
28910 wxPyEndAllowThreads(__tstate);
28911 if (PyErr_Occurred()) SWIG_fail;
28912 }
28913 Py_INCREF(Py_None); resultobj = Py_None;
28914 return resultobj;
28915 fail:
28916 return NULL;
28917 }
28918
28919
28920 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28921 PyObject *resultobj;
28922 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28923 PyObject * obj0 = 0 ;
28924 char *kwnames[] = {
28925 (char *) "self", NULL
28926 };
28927
28928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28930 if (SWIG_arg_fail(1)) SWIG_fail;
28931 {
28932 PyThreadState* __tstate = wxPyBeginAllowThreads();
28933 delete arg1;
28934
28935 wxPyEndAllowThreads(__tstate);
28936 if (PyErr_Occurred()) SWIG_fail;
28937 }
28938 Py_INCREF(Py_None); resultobj = Py_None;
28939 return resultobj;
28940 fail:
28941 return NULL;
28942 }
28943
28944
28945 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28946 PyObject *resultobj;
28947 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28948 wxDataObject *result;
28949 PyObject * obj0 = 0 ;
28950 char *kwnames[] = {
28951 (char *) "self", NULL
28952 };
28953
28954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28956 if (SWIG_arg_fail(1)) SWIG_fail;
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 result = (wxDataObject *)(arg1)->GetDataObject();
28960
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28965 return resultobj;
28966 fail:
28967 return NULL;
28968 }
28969
28970
28971 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28972 PyObject *resultobj;
28973 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28974 wxDataObject *arg2 = (wxDataObject *) 0 ;
28975 PyObject * obj0 = 0 ;
28976 PyObject * obj1 = 0 ;
28977 char *kwnames[] = {
28978 (char *) "self",(char *) "dataObject", NULL
28979 };
28980
28981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28983 if (SWIG_arg_fail(1)) SWIG_fail;
28984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28985 if (SWIG_arg_fail(2)) SWIG_fail;
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 (arg1)->SetDataObject(arg2);
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 Py_INCREF(Py_None); resultobj = Py_None;
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29001 PyObject *resultobj;
29002 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29003 int arg2 ;
29004 int arg3 ;
29005 wxDragResult arg4 ;
29006 wxDragResult result;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 PyObject * obj2 = 0 ;
29010 PyObject * obj3 = 0 ;
29011 char *kwnames[] = {
29012 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29013 };
29014
29015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29017 if (SWIG_arg_fail(1)) SWIG_fail;
29018 {
29019 arg2 = (int)(SWIG_As_int(obj1));
29020 if (SWIG_arg_fail(2)) SWIG_fail;
29021 }
29022 {
29023 arg3 = (int)(SWIG_As_int(obj2));
29024 if (SWIG_arg_fail(3)) SWIG_fail;
29025 }
29026 {
29027 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29028 if (SWIG_arg_fail(4)) SWIG_fail;
29029 }
29030 {
29031 PyThreadState* __tstate = wxPyBeginAllowThreads();
29032 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29033
29034 wxPyEndAllowThreads(__tstate);
29035 if (PyErr_Occurred()) SWIG_fail;
29036 }
29037 resultobj = SWIG_From_int((result));
29038 return resultobj;
29039 fail:
29040 return NULL;
29041 }
29042
29043
29044 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29045 PyObject *resultobj;
29046 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29047 int arg2 ;
29048 int arg3 ;
29049 wxDragResult arg4 ;
29050 wxDragResult result;
29051 PyObject * obj0 = 0 ;
29052 PyObject * obj1 = 0 ;
29053 PyObject * obj2 = 0 ;
29054 PyObject * obj3 = 0 ;
29055 char *kwnames[] = {
29056 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29057 };
29058
29059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29061 if (SWIG_arg_fail(1)) SWIG_fail;
29062 {
29063 arg2 = (int)(SWIG_As_int(obj1));
29064 if (SWIG_arg_fail(2)) SWIG_fail;
29065 }
29066 {
29067 arg3 = (int)(SWIG_As_int(obj2));
29068 if (SWIG_arg_fail(3)) SWIG_fail;
29069 }
29070 {
29071 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29072 if (SWIG_arg_fail(4)) SWIG_fail;
29073 }
29074 {
29075 PyThreadState* __tstate = wxPyBeginAllowThreads();
29076 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29077
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_From_int((result));
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj;
29090 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29091 PyObject * obj0 = 0 ;
29092 char *kwnames[] = {
29093 (char *) "self", NULL
29094 };
29095
29096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29098 if (SWIG_arg_fail(1)) SWIG_fail;
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 (arg1)->base_OnLeave();
29102
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 Py_INCREF(Py_None); resultobj = Py_None;
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29114 PyObject *resultobj;
29115 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29116 int arg2 ;
29117 int arg3 ;
29118 bool result;
29119 PyObject * obj0 = 0 ;
29120 PyObject * obj1 = 0 ;
29121 PyObject * obj2 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self",(char *) "x",(char *) "y", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29128 if (SWIG_arg_fail(1)) SWIG_fail;
29129 {
29130 arg2 = (int)(SWIG_As_int(obj1));
29131 if (SWIG_arg_fail(2)) SWIG_fail;
29132 }
29133 {
29134 arg3 = (int)(SWIG_As_int(obj2));
29135 if (SWIG_arg_fail(3)) SWIG_fail;
29136 }
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29140
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 {
29145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29146 }
29147 return resultobj;
29148 fail:
29149 return NULL;
29150 }
29151
29152
29153 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj;
29155 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29156 bool result;
29157 PyObject * obj0 = 0 ;
29158 char *kwnames[] = {
29159 (char *) "self", NULL
29160 };
29161
29162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29164 if (SWIG_arg_fail(1)) SWIG_fail;
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 result = (bool)(arg1)->GetData();
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 {
29173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29174 }
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29184 wxDragResult arg2 ;
29185 PyObject * obj0 = 0 ;
29186 PyObject * obj1 = 0 ;
29187 char *kwnames[] = {
29188 (char *) "self",(char *) "action", NULL
29189 };
29190
29191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29193 if (SWIG_arg_fail(1)) SWIG_fail;
29194 {
29195 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29196 if (SWIG_arg_fail(2)) SWIG_fail;
29197 }
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 (arg1)->SetDefaultAction((wxDragResult )arg2);
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 Py_INCREF(Py_None); resultobj = Py_None;
29206 return resultobj;
29207 fail:
29208 return NULL;
29209 }
29210
29211
29212 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29213 PyObject *resultobj;
29214 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29215 wxDragResult result;
29216 PyObject * obj0 = 0 ;
29217 char *kwnames[] = {
29218 (char *) "self", NULL
29219 };
29220
29221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29223 if (SWIG_arg_fail(1)) SWIG_fail;
29224 {
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 result = (wxDragResult)(arg1)->GetDefaultAction();
29227
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 resultobj = SWIG_From_int((result));
29232 return resultobj;
29233 fail:
29234 return NULL;
29235 }
29236
29237
29238 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29239 PyObject *obj;
29240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29241 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29242 Py_INCREF(obj);
29243 return Py_BuildValue((char *)"");
29244 }
29245 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29246 PyObject *resultobj;
29247 wxPyTextDropTarget *result;
29248 char *kwnames[] = {
29249 NULL
29250 };
29251
29252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj;
29269 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29270 PyObject *arg2 = (PyObject *) 0 ;
29271 PyObject *arg3 = (PyObject *) 0 ;
29272 PyObject * obj0 = 0 ;
29273 PyObject * obj1 = 0 ;
29274 PyObject * obj2 = 0 ;
29275 char *kwnames[] = {
29276 (char *) "self",(char *) "self",(char *) "_class", NULL
29277 };
29278
29279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29281 if (SWIG_arg_fail(1)) SWIG_fail;
29282 arg2 = obj1;
29283 arg3 = obj2;
29284 {
29285 PyThreadState* __tstate = wxPyBeginAllowThreads();
29286 (arg1)->_setCallbackInfo(arg2,arg3);
29287
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 Py_INCREF(Py_None); resultobj = Py_None;
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj;
29300 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29301 int arg2 ;
29302 int arg3 ;
29303 wxDragResult arg4 ;
29304 wxDragResult result;
29305 PyObject * obj0 = 0 ;
29306 PyObject * obj1 = 0 ;
29307 PyObject * obj2 = 0 ;
29308 PyObject * obj3 = 0 ;
29309 char *kwnames[] = {
29310 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29311 };
29312
29313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29315 if (SWIG_arg_fail(1)) SWIG_fail;
29316 {
29317 arg2 = (int)(SWIG_As_int(obj1));
29318 if (SWIG_arg_fail(2)) SWIG_fail;
29319 }
29320 {
29321 arg3 = (int)(SWIG_As_int(obj2));
29322 if (SWIG_arg_fail(3)) SWIG_fail;
29323 }
29324 {
29325 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29326 if (SWIG_arg_fail(4)) SWIG_fail;
29327 }
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 resultobj = SWIG_From_int((result));
29336 return resultobj;
29337 fail:
29338 return NULL;
29339 }
29340
29341
29342 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29343 PyObject *resultobj;
29344 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29345 int arg2 ;
29346 int arg3 ;
29347 wxDragResult arg4 ;
29348 wxDragResult result;
29349 PyObject * obj0 = 0 ;
29350 PyObject * obj1 = 0 ;
29351 PyObject * obj2 = 0 ;
29352 PyObject * obj3 = 0 ;
29353 char *kwnames[] = {
29354 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29355 };
29356
29357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29359 if (SWIG_arg_fail(1)) SWIG_fail;
29360 {
29361 arg2 = (int)(SWIG_As_int(obj1));
29362 if (SWIG_arg_fail(2)) SWIG_fail;
29363 }
29364 {
29365 arg3 = (int)(SWIG_As_int(obj2));
29366 if (SWIG_arg_fail(3)) SWIG_fail;
29367 }
29368 {
29369 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29370 if (SWIG_arg_fail(4)) SWIG_fail;
29371 }
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29375
29376 wxPyEndAllowThreads(__tstate);
29377 if (PyErr_Occurred()) SWIG_fail;
29378 }
29379 resultobj = SWIG_From_int((result));
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29387 PyObject *resultobj;
29388 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29389 PyObject * obj0 = 0 ;
29390 char *kwnames[] = {
29391 (char *) "self", NULL
29392 };
29393
29394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29396 if (SWIG_arg_fail(1)) SWIG_fail;
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 (arg1)->base_OnLeave();
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 Py_INCREF(Py_None); resultobj = Py_None;
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29412 PyObject *resultobj;
29413 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29414 int arg2 ;
29415 int arg3 ;
29416 bool result;
29417 PyObject * obj0 = 0 ;
29418 PyObject * obj1 = 0 ;
29419 PyObject * obj2 = 0 ;
29420 char *kwnames[] = {
29421 (char *) "self",(char *) "x",(char *) "y", NULL
29422 };
29423
29424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29426 if (SWIG_arg_fail(1)) SWIG_fail;
29427 {
29428 arg2 = (int)(SWIG_As_int(obj1));
29429 if (SWIG_arg_fail(2)) SWIG_fail;
29430 }
29431 {
29432 arg3 = (int)(SWIG_As_int(obj2));
29433 if (SWIG_arg_fail(3)) SWIG_fail;
29434 }
29435 {
29436 PyThreadState* __tstate = wxPyBeginAllowThreads();
29437 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29438
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 {
29443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29444 }
29445 return resultobj;
29446 fail:
29447 return NULL;
29448 }
29449
29450
29451 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29452 PyObject *resultobj;
29453 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29454 int arg2 ;
29455 int arg3 ;
29456 wxDragResult arg4 ;
29457 wxDragResult result;
29458 PyObject * obj0 = 0 ;
29459 PyObject * obj1 = 0 ;
29460 PyObject * obj2 = 0 ;
29461 PyObject * obj3 = 0 ;
29462 char *kwnames[] = {
29463 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29464 };
29465
29466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29468 if (SWIG_arg_fail(1)) SWIG_fail;
29469 {
29470 arg2 = (int)(SWIG_As_int(obj1));
29471 if (SWIG_arg_fail(2)) SWIG_fail;
29472 }
29473 {
29474 arg3 = (int)(SWIG_As_int(obj2));
29475 if (SWIG_arg_fail(3)) SWIG_fail;
29476 }
29477 {
29478 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29479 if (SWIG_arg_fail(4)) SWIG_fail;
29480 }
29481 {
29482 PyThreadState* __tstate = wxPyBeginAllowThreads();
29483 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29484
29485 wxPyEndAllowThreads(__tstate);
29486 if (PyErr_Occurred()) SWIG_fail;
29487 }
29488 resultobj = SWIG_From_int((result));
29489 return resultobj;
29490 fail:
29491 return NULL;
29492 }
29493
29494
29495 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29496 PyObject *obj;
29497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29498 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29499 Py_INCREF(obj);
29500 return Py_BuildValue((char *)"");
29501 }
29502 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29503 PyObject *resultobj;
29504 wxPyFileDropTarget *result;
29505 char *kwnames[] = {
29506 NULL
29507 };
29508
29509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29510 {
29511 PyThreadState* __tstate = wxPyBeginAllowThreads();
29512 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29513
29514 wxPyEndAllowThreads(__tstate);
29515 if (PyErr_Occurred()) SWIG_fail;
29516 }
29517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29518 return resultobj;
29519 fail:
29520 return NULL;
29521 }
29522
29523
29524 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29525 PyObject *resultobj;
29526 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29527 PyObject *arg2 = (PyObject *) 0 ;
29528 PyObject *arg3 = (PyObject *) 0 ;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 PyObject * obj2 = 0 ;
29532 char *kwnames[] = {
29533 (char *) "self",(char *) "self",(char *) "_class", NULL
29534 };
29535
29536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29538 if (SWIG_arg_fail(1)) SWIG_fail;
29539 arg2 = obj1;
29540 arg3 = obj2;
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 (arg1)->_setCallbackInfo(arg2,arg3);
29544
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 Py_INCREF(Py_None); resultobj = Py_None;
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj;
29557 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29558 int arg2 ;
29559 int arg3 ;
29560 wxDragResult arg4 ;
29561 wxDragResult result;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 PyObject * obj2 = 0 ;
29565 PyObject * obj3 = 0 ;
29566 char *kwnames[] = {
29567 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29568 };
29569
29570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29572 if (SWIG_arg_fail(1)) SWIG_fail;
29573 {
29574 arg2 = (int)(SWIG_As_int(obj1));
29575 if (SWIG_arg_fail(2)) SWIG_fail;
29576 }
29577 {
29578 arg3 = (int)(SWIG_As_int(obj2));
29579 if (SWIG_arg_fail(3)) SWIG_fail;
29580 }
29581 {
29582 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29583 if (SWIG_arg_fail(4)) SWIG_fail;
29584 }
29585 {
29586 PyThreadState* __tstate = wxPyBeginAllowThreads();
29587 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29588
29589 wxPyEndAllowThreads(__tstate);
29590 if (PyErr_Occurred()) SWIG_fail;
29591 }
29592 resultobj = SWIG_From_int((result));
29593 return resultobj;
29594 fail:
29595 return NULL;
29596 }
29597
29598
29599 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29600 PyObject *resultobj;
29601 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29602 int arg2 ;
29603 int arg3 ;
29604 wxDragResult arg4 ;
29605 wxDragResult result;
29606 PyObject * obj0 = 0 ;
29607 PyObject * obj1 = 0 ;
29608 PyObject * obj2 = 0 ;
29609 PyObject * obj3 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29616 if (SWIG_arg_fail(1)) SWIG_fail;
29617 {
29618 arg2 = (int)(SWIG_As_int(obj1));
29619 if (SWIG_arg_fail(2)) SWIG_fail;
29620 }
29621 {
29622 arg3 = (int)(SWIG_As_int(obj2));
29623 if (SWIG_arg_fail(3)) SWIG_fail;
29624 }
29625 {
29626 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29627 if (SWIG_arg_fail(4)) SWIG_fail;
29628 }
29629 {
29630 PyThreadState* __tstate = wxPyBeginAllowThreads();
29631 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29632
29633 wxPyEndAllowThreads(__tstate);
29634 if (PyErr_Occurred()) SWIG_fail;
29635 }
29636 resultobj = SWIG_From_int((result));
29637 return resultobj;
29638 fail:
29639 return NULL;
29640 }
29641
29642
29643 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29644 PyObject *resultobj;
29645 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29646 PyObject * obj0 = 0 ;
29647 char *kwnames[] = {
29648 (char *) "self", NULL
29649 };
29650
29651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29653 if (SWIG_arg_fail(1)) SWIG_fail;
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 (arg1)->base_OnLeave();
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 Py_INCREF(Py_None); resultobj = Py_None;
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj;
29670 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29671 int arg2 ;
29672 int arg3 ;
29673 bool result;
29674 PyObject * obj0 = 0 ;
29675 PyObject * obj1 = 0 ;
29676 PyObject * obj2 = 0 ;
29677 char *kwnames[] = {
29678 (char *) "self",(char *) "x",(char *) "y", NULL
29679 };
29680
29681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29683 if (SWIG_arg_fail(1)) SWIG_fail;
29684 {
29685 arg2 = (int)(SWIG_As_int(obj1));
29686 if (SWIG_arg_fail(2)) SWIG_fail;
29687 }
29688 {
29689 arg3 = (int)(SWIG_As_int(obj2));
29690 if (SWIG_arg_fail(3)) SWIG_fail;
29691 }
29692 {
29693 PyThreadState* __tstate = wxPyBeginAllowThreads();
29694 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29695
29696 wxPyEndAllowThreads(__tstate);
29697 if (PyErr_Occurred()) SWIG_fail;
29698 }
29699 {
29700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29701 }
29702 return resultobj;
29703 fail:
29704 return NULL;
29705 }
29706
29707
29708 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29709 PyObject *resultobj;
29710 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29711 int arg2 ;
29712 int arg3 ;
29713 wxDragResult arg4 ;
29714 wxDragResult result;
29715 PyObject * obj0 = 0 ;
29716 PyObject * obj1 = 0 ;
29717 PyObject * obj2 = 0 ;
29718 PyObject * obj3 = 0 ;
29719 char *kwnames[] = {
29720 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29721 };
29722
29723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29725 if (SWIG_arg_fail(1)) SWIG_fail;
29726 {
29727 arg2 = (int)(SWIG_As_int(obj1));
29728 if (SWIG_arg_fail(2)) SWIG_fail;
29729 }
29730 {
29731 arg3 = (int)(SWIG_As_int(obj2));
29732 if (SWIG_arg_fail(3)) SWIG_fail;
29733 }
29734 {
29735 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29736 if (SWIG_arg_fail(4)) SWIG_fail;
29737 }
29738 {
29739 PyThreadState* __tstate = wxPyBeginAllowThreads();
29740 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29741
29742 wxPyEndAllowThreads(__tstate);
29743 if (PyErr_Occurred()) SWIG_fail;
29744 }
29745 resultobj = SWIG_From_int((result));
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29753 PyObject *obj;
29754 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29755 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29756 Py_INCREF(obj);
29757 return Py_BuildValue((char *)"");
29758 }
29759 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29760 PyObject *resultobj;
29761 wxClipboard *result;
29762 char *kwnames[] = {
29763 NULL
29764 };
29765
29766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29767 {
29768 PyThreadState* __tstate = wxPyBeginAllowThreads();
29769 result = (wxClipboard *)new wxClipboard();
29770
29771 wxPyEndAllowThreads(__tstate);
29772 if (PyErr_Occurred()) SWIG_fail;
29773 }
29774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj;
29783 wxClipboard *arg1 = (wxClipboard *) 0 ;
29784 PyObject * obj0 = 0 ;
29785 char *kwnames[] = {
29786 (char *) "self", NULL
29787 };
29788
29789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29791 if (SWIG_arg_fail(1)) SWIG_fail;
29792 {
29793 PyThreadState* __tstate = wxPyBeginAllowThreads();
29794 delete arg1;
29795
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 Py_INCREF(Py_None); resultobj = Py_None;
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj;
29808 wxClipboard *arg1 = (wxClipboard *) 0 ;
29809 bool result;
29810 PyObject * obj0 = 0 ;
29811 char *kwnames[] = {
29812 (char *) "self", NULL
29813 };
29814
29815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29817 if (SWIG_arg_fail(1)) SWIG_fail;
29818 {
29819 PyThreadState* __tstate = wxPyBeginAllowThreads();
29820 result = (bool)(arg1)->Open();
29821
29822 wxPyEndAllowThreads(__tstate);
29823 if (PyErr_Occurred()) SWIG_fail;
29824 }
29825 {
29826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29827 }
29828 return resultobj;
29829 fail:
29830 return NULL;
29831 }
29832
29833
29834 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29835 PyObject *resultobj;
29836 wxClipboard *arg1 = (wxClipboard *) 0 ;
29837 PyObject * obj0 = 0 ;
29838 char *kwnames[] = {
29839 (char *) "self", NULL
29840 };
29841
29842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29844 if (SWIG_arg_fail(1)) SWIG_fail;
29845 {
29846 PyThreadState* __tstate = wxPyBeginAllowThreads();
29847 (arg1)->Close();
29848
29849 wxPyEndAllowThreads(__tstate);
29850 if (PyErr_Occurred()) SWIG_fail;
29851 }
29852 Py_INCREF(Py_None); resultobj = Py_None;
29853 return resultobj;
29854 fail:
29855 return NULL;
29856 }
29857
29858
29859 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29860 PyObject *resultobj;
29861 wxClipboard *arg1 = (wxClipboard *) 0 ;
29862 bool result;
29863 PyObject * obj0 = 0 ;
29864 char *kwnames[] = {
29865 (char *) "self", NULL
29866 };
29867
29868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29870 if (SWIG_arg_fail(1)) SWIG_fail;
29871 {
29872 PyThreadState* __tstate = wxPyBeginAllowThreads();
29873 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29874
29875 wxPyEndAllowThreads(__tstate);
29876 if (PyErr_Occurred()) SWIG_fail;
29877 }
29878 {
29879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29880 }
29881 return resultobj;
29882 fail:
29883 return NULL;
29884 }
29885
29886
29887 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29888 PyObject *resultobj;
29889 wxClipboard *arg1 = (wxClipboard *) 0 ;
29890 wxDataObject *arg2 = (wxDataObject *) 0 ;
29891 bool result;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char *kwnames[] = {
29895 (char *) "self",(char *) "data", NULL
29896 };
29897
29898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(1)) SWIG_fail;
29901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29902 if (SWIG_arg_fail(2)) SWIG_fail;
29903 {
29904 PyThreadState* __tstate = wxPyBeginAllowThreads();
29905 result = (bool)(arg1)->AddData(arg2);
29906
29907 wxPyEndAllowThreads(__tstate);
29908 if (PyErr_Occurred()) SWIG_fail;
29909 }
29910 {
29911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29912 }
29913 return resultobj;
29914 fail:
29915 return NULL;
29916 }
29917
29918
29919 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29920 PyObject *resultobj;
29921 wxClipboard *arg1 = (wxClipboard *) 0 ;
29922 wxDataObject *arg2 = (wxDataObject *) 0 ;
29923 bool result;
29924 PyObject * obj0 = 0 ;
29925 PyObject * obj1 = 0 ;
29926 char *kwnames[] = {
29927 (char *) "self",(char *) "data", NULL
29928 };
29929
29930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29932 if (SWIG_arg_fail(1)) SWIG_fail;
29933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29934 if (SWIG_arg_fail(2)) SWIG_fail;
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 result = (bool)(arg1)->SetData(arg2);
29938
29939 wxPyEndAllowThreads(__tstate);
29940 if (PyErr_Occurred()) SWIG_fail;
29941 }
29942 {
29943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29944 }
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29952 PyObject *resultobj;
29953 wxClipboard *arg1 = (wxClipboard *) 0 ;
29954 wxDataFormat *arg2 = 0 ;
29955 bool result;
29956 PyObject * obj0 = 0 ;
29957 PyObject * obj1 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self",(char *) "format", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29967 if (SWIG_arg_fail(2)) SWIG_fail;
29968 if (arg2 == NULL) {
29969 SWIG_null_ref("wxDataFormat");
29970 }
29971 if (SWIG_arg_fail(2)) SWIG_fail;
29972 }
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 {
29981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29982 }
29983 return resultobj;
29984 fail:
29985 return NULL;
29986 }
29987
29988
29989 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29990 PyObject *resultobj;
29991 wxClipboard *arg1 = (wxClipboard *) 0 ;
29992 wxDataObject *arg2 = 0 ;
29993 bool result;
29994 PyObject * obj0 = 0 ;
29995 PyObject * obj1 = 0 ;
29996 char *kwnames[] = {
29997 (char *) "self",(char *) "data", NULL
29998 };
29999
30000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
30001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30002 if (SWIG_arg_fail(1)) SWIG_fail;
30003 {
30004 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
30005 if (SWIG_arg_fail(2)) SWIG_fail;
30006 if (arg2 == NULL) {
30007 SWIG_null_ref("wxDataObject");
30008 }
30009 if (SWIG_arg_fail(2)) SWIG_fail;
30010 }
30011 {
30012 PyThreadState* __tstate = wxPyBeginAllowThreads();
30013 result = (bool)(arg1)->GetData(*arg2);
30014
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 {
30019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30020 }
30021 return resultobj;
30022 fail:
30023 return NULL;
30024 }
30025
30026
30027 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
30028 PyObject *resultobj;
30029 wxClipboard *arg1 = (wxClipboard *) 0 ;
30030 PyObject * obj0 = 0 ;
30031 char *kwnames[] = {
30032 (char *) "self", NULL
30033 };
30034
30035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30037 if (SWIG_arg_fail(1)) SWIG_fail;
30038 {
30039 PyThreadState* __tstate = wxPyBeginAllowThreads();
30040 (arg1)->Clear();
30041
30042 wxPyEndAllowThreads(__tstate);
30043 if (PyErr_Occurred()) SWIG_fail;
30044 }
30045 Py_INCREF(Py_None); resultobj = Py_None;
30046 return resultobj;
30047 fail:
30048 return NULL;
30049 }
30050
30051
30052 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30053 PyObject *resultobj;
30054 wxClipboard *arg1 = (wxClipboard *) 0 ;
30055 bool result;
30056 PyObject * obj0 = 0 ;
30057 char *kwnames[] = {
30058 (char *) "self", NULL
30059 };
30060
30061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30063 if (SWIG_arg_fail(1)) SWIG_fail;
30064 {
30065 PyThreadState* __tstate = wxPyBeginAllowThreads();
30066 result = (bool)(arg1)->Flush();
30067
30068 wxPyEndAllowThreads(__tstate);
30069 if (PyErr_Occurred()) SWIG_fail;
30070 }
30071 {
30072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30073 }
30074 return resultobj;
30075 fail:
30076 return NULL;
30077 }
30078
30079
30080 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30081 PyObject *resultobj;
30082 wxClipboard *arg1 = (wxClipboard *) 0 ;
30083 bool arg2 = (bool) true ;
30084 PyObject * obj0 = 0 ;
30085 PyObject * obj1 = 0 ;
30086 char *kwnames[] = {
30087 (char *) "self",(char *) "primary", NULL
30088 };
30089
30090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30092 if (SWIG_arg_fail(1)) SWIG_fail;
30093 if (obj1) {
30094 {
30095 arg2 = (bool)(SWIG_As_bool(obj1));
30096 if (SWIG_arg_fail(2)) SWIG_fail;
30097 }
30098 }
30099 {
30100 PyThreadState* __tstate = wxPyBeginAllowThreads();
30101 (arg1)->UsePrimarySelection(arg2);
30102
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 Py_INCREF(Py_None); resultobj = Py_None;
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30114 PyObject *resultobj;
30115 wxClipboard *result;
30116 char *kwnames[] = {
30117 NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 result = (wxClipboard *)wxClipboard::Get();
30124
30125 wxPyEndAllowThreads(__tstate);
30126 if (PyErr_Occurred()) SWIG_fail;
30127 }
30128 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30136 PyObject *obj;
30137 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30138 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30139 Py_INCREF(obj);
30140 return Py_BuildValue((char *)"");
30141 }
30142 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30143 PyObject *resultobj;
30144 wxClipboard *arg1 = (wxClipboard *) NULL ;
30145 wxClipboardLocker *result;
30146 PyObject * obj0 = 0 ;
30147 char *kwnames[] = {
30148 (char *) "clipboard", NULL
30149 };
30150
30151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30152 if (obj0) {
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30173 PyObject * obj0 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 delete arg1;
30184
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 Py_INCREF(Py_None); resultobj = Py_None;
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj;
30197 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30198 bool result;
30199 PyObject * obj0 = 0 ;
30200 char *kwnames[] = {
30201 (char *) "self", NULL
30202 };
30203
30204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(1)) SWIG_fail;
30207 {
30208 PyThreadState* __tstate = wxPyBeginAllowThreads();
30209 result = (bool)wxClipboardLocker___nonzero__(arg1);
30210
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 {
30215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30216 }
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30224 PyObject *obj;
30225 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30226 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30227 Py_INCREF(obj);
30228 return Py_BuildValue((char *)"");
30229 }
30230 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30231 PyObject *resultobj;
30232 int arg1 = (int) 0 ;
30233 int arg2 = (int) 0 ;
30234 int arg3 = (int) 0 ;
30235 int arg4 = (int) 0 ;
30236 wxVideoMode *result;
30237 PyObject * obj0 = 0 ;
30238 PyObject * obj1 = 0 ;
30239 PyObject * obj2 = 0 ;
30240 PyObject * obj3 = 0 ;
30241 char *kwnames[] = {
30242 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30243 };
30244
30245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30246 if (obj0) {
30247 {
30248 arg1 = (int)(SWIG_As_int(obj0));
30249 if (SWIG_arg_fail(1)) SWIG_fail;
30250 }
30251 }
30252 if (obj1) {
30253 {
30254 arg2 = (int)(SWIG_As_int(obj1));
30255 if (SWIG_arg_fail(2)) SWIG_fail;
30256 }
30257 }
30258 if (obj2) {
30259 {
30260 arg3 = (int)(SWIG_As_int(obj2));
30261 if (SWIG_arg_fail(3)) SWIG_fail;
30262 }
30263 }
30264 if (obj3) {
30265 {
30266 arg4 = (int)(SWIG_As_int(obj3));
30267 if (SWIG_arg_fail(4)) SWIG_fail;
30268 }
30269 }
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30273
30274 wxPyEndAllowThreads(__tstate);
30275 if (PyErr_Occurred()) SWIG_fail;
30276 }
30277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30278 return resultobj;
30279 fail:
30280 return NULL;
30281 }
30282
30283
30284 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30285 PyObject *resultobj;
30286 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30287 PyObject * obj0 = 0 ;
30288 char *kwnames[] = {
30289 (char *) "self", NULL
30290 };
30291
30292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30294 if (SWIG_arg_fail(1)) SWIG_fail;
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 delete arg1;
30298
30299 wxPyEndAllowThreads(__tstate);
30300 if (PyErr_Occurred()) SWIG_fail;
30301 }
30302 Py_INCREF(Py_None); resultobj = Py_None;
30303 return resultobj;
30304 fail:
30305 return NULL;
30306 }
30307
30308
30309 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30310 PyObject *resultobj;
30311 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30312 wxVideoMode *arg2 = 0 ;
30313 bool result;
30314 PyObject * obj0 = 0 ;
30315 PyObject * obj1 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self",(char *) "other", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30322 if (SWIG_arg_fail(1)) SWIG_fail;
30323 {
30324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30325 if (SWIG_arg_fail(2)) SWIG_fail;
30326 if (arg2 == NULL) {
30327 SWIG_null_ref("wxVideoMode");
30328 }
30329 if (SWIG_arg_fail(2)) SWIG_fail;
30330 }
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30334
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 {
30339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30340 }
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj;
30349 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30350 int result;
30351 PyObject * obj0 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30362
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 {
30367 resultobj = SWIG_From_int((int)(result));
30368 }
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30378 int result;
30379 PyObject * obj0 = 0 ;
30380 char *kwnames[] = {
30381 (char *) "self", NULL
30382 };
30383
30384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30386 if (SWIG_arg_fail(1)) SWIG_fail;
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30390
30391 wxPyEndAllowThreads(__tstate);
30392 if (PyErr_Occurred()) SWIG_fail;
30393 }
30394 {
30395 resultobj = SWIG_From_int((int)(result));
30396 }
30397 return resultobj;
30398 fail:
30399 return NULL;
30400 }
30401
30402
30403 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30404 PyObject *resultobj;
30405 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30406 int result;
30407 PyObject * obj0 = 0 ;
30408 char *kwnames[] = {
30409 (char *) "self", NULL
30410 };
30411
30412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30414 if (SWIG_arg_fail(1)) SWIG_fail;
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 resultobj = SWIG_From_int((int)(result));
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30434 bool result;
30435 PyObject * obj0 = 0 ;
30436 char *kwnames[] = {
30437 (char *) "self", NULL
30438 };
30439
30440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(1)) SWIG_fail;
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30462 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30463 bool result;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 char *kwnames[] = {
30467 (char *) "self",(char *) "other", NULL
30468 };
30469
30470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30472 if (SWIG_arg_fail(1)) SWIG_fail;
30473 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30474 if (SWIG_arg_fail(2)) SWIG_fail;
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30478
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 {
30483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30484 }
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj;
30493 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30494 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30495 bool result;
30496 PyObject * obj0 = 0 ;
30497 PyObject * obj1 = 0 ;
30498 char *kwnames[] = {
30499 (char *) "self",(char *) "other", NULL
30500 };
30501
30502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30504 if (SWIG_arg_fail(1)) SWIG_fail;
30505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30506 if (SWIG_arg_fail(2)) SWIG_fail;
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30510
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 {
30515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30516 }
30517 return resultobj;
30518 fail:
30519 return NULL;
30520 }
30521
30522
30523 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30524 PyObject *resultobj;
30525 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30526 int arg2 ;
30527 PyObject * obj0 = 0 ;
30528 PyObject * obj1 = 0 ;
30529 char *kwnames[] = {
30530 (char *) "self",(char *) "w", NULL
30531 };
30532
30533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30535 if (SWIG_arg_fail(1)) SWIG_fail;
30536 {
30537 arg2 = (int)(SWIG_As_int(obj1));
30538 if (SWIG_arg_fail(2)) SWIG_fail;
30539 }
30540 if (arg1) (arg1)->w = arg2;
30541
30542 Py_INCREF(Py_None); resultobj = Py_None;
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30552 int result;
30553 PyObject * obj0 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 result = (int) ((arg1)->w);
30562
30563 {
30564 resultobj = SWIG_From_int((int)(result));
30565 }
30566 return resultobj;
30567 fail:
30568 return NULL;
30569 }
30570
30571
30572 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30573 PyObject *resultobj;
30574 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30575 int arg2 ;
30576 PyObject * obj0 = 0 ;
30577 PyObject * obj1 = 0 ;
30578 char *kwnames[] = {
30579 (char *) "self",(char *) "h", NULL
30580 };
30581
30582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30584 if (SWIG_arg_fail(1)) SWIG_fail;
30585 {
30586 arg2 = (int)(SWIG_As_int(obj1));
30587 if (SWIG_arg_fail(2)) SWIG_fail;
30588 }
30589 if (arg1) (arg1)->h = arg2;
30590
30591 Py_INCREF(Py_None); resultobj = Py_None;
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj;
30600 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30601 int result;
30602 PyObject * obj0 = 0 ;
30603 char *kwnames[] = {
30604 (char *) "self", NULL
30605 };
30606
30607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30609 if (SWIG_arg_fail(1)) SWIG_fail;
30610 result = (int) ((arg1)->h);
30611
30612 {
30613 resultobj = SWIG_From_int((int)(result));
30614 }
30615 return resultobj;
30616 fail:
30617 return NULL;
30618 }
30619
30620
30621 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30622 PyObject *resultobj;
30623 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30624 int arg2 ;
30625 PyObject * obj0 = 0 ;
30626 PyObject * obj1 = 0 ;
30627 char *kwnames[] = {
30628 (char *) "self",(char *) "bpp", NULL
30629 };
30630
30631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30633 if (SWIG_arg_fail(1)) SWIG_fail;
30634 {
30635 arg2 = (int)(SWIG_As_int(obj1));
30636 if (SWIG_arg_fail(2)) SWIG_fail;
30637 }
30638 if (arg1) (arg1)->bpp = arg2;
30639
30640 Py_INCREF(Py_None); resultobj = Py_None;
30641 return resultobj;
30642 fail:
30643 return NULL;
30644 }
30645
30646
30647 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30648 PyObject *resultobj;
30649 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30650 int result;
30651 PyObject * obj0 = 0 ;
30652 char *kwnames[] = {
30653 (char *) "self", NULL
30654 };
30655
30656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30658 if (SWIG_arg_fail(1)) SWIG_fail;
30659 result = (int) ((arg1)->bpp);
30660
30661 {
30662 resultobj = SWIG_From_int((int)(result));
30663 }
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30671 PyObject *resultobj;
30672 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30673 int arg2 ;
30674 PyObject * obj0 = 0 ;
30675 PyObject * obj1 = 0 ;
30676 char *kwnames[] = {
30677 (char *) "self",(char *) "refresh", NULL
30678 };
30679
30680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30682 if (SWIG_arg_fail(1)) SWIG_fail;
30683 {
30684 arg2 = (int)(SWIG_As_int(obj1));
30685 if (SWIG_arg_fail(2)) SWIG_fail;
30686 }
30687 if (arg1) (arg1)->refresh = arg2;
30688
30689 Py_INCREF(Py_None); resultobj = Py_None;
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30697 PyObject *resultobj;
30698 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30699 int result;
30700 PyObject * obj0 = 0 ;
30701 char *kwnames[] = {
30702 (char *) "self", NULL
30703 };
30704
30705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 result = (int) ((arg1)->refresh);
30709
30710 {
30711 resultobj = SWIG_From_int((int)(result));
30712 }
30713 return resultobj;
30714 fail:
30715 return NULL;
30716 }
30717
30718
30719 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30720 PyObject *obj;
30721 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30722 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30723 Py_INCREF(obj);
30724 return Py_BuildValue((char *)"");
30725 }
30726 static int _wrap_DefaultVideoMode_set(PyObject *) {
30727 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30728 return 1;
30729 }
30730
30731
30732 static PyObject *_wrap_DefaultVideoMode_get(void) {
30733 PyObject *pyobj;
30734
30735 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30736 return pyobj;
30737 }
30738
30739
30740 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30741 PyObject *resultobj;
30742 size_t arg1 = (size_t) 0 ;
30743 wxDisplay *result;
30744 PyObject * obj0 = 0 ;
30745 char *kwnames[] = {
30746 (char *) "index", NULL
30747 };
30748
30749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30750 if (obj0) {
30751 {
30752 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30753 if (SWIG_arg_fail(1)) SWIG_fail;
30754 }
30755 }
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = (wxDisplay *)new wxDisplay(arg1);
30759
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30764 return resultobj;
30765 fail:
30766 return NULL;
30767 }
30768
30769
30770 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30771 PyObject *resultobj;
30772 wxDisplay *arg1 = (wxDisplay *) 0 ;
30773 PyObject * obj0 = 0 ;
30774 char *kwnames[] = {
30775 (char *) "self", NULL
30776 };
30777
30778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30780 if (SWIG_arg_fail(1)) SWIG_fail;
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 delete arg1;
30784
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 Py_INCREF(Py_None); resultobj = Py_None;
30789 return resultobj;
30790 fail:
30791 return NULL;
30792 }
30793
30794
30795 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30796 PyObject *resultobj;
30797 size_t result;
30798 char *kwnames[] = {
30799 NULL
30800 };
30801
30802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = (size_t)wxDisplay::GetCount();
30806
30807 wxPyEndAllowThreads(__tstate);
30808 if (PyErr_Occurred()) SWIG_fail;
30809 }
30810 {
30811 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30812 }
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj;
30821 wxPoint *arg1 = 0 ;
30822 int result;
30823 wxPoint temp1 ;
30824 PyObject * obj0 = 0 ;
30825 char *kwnames[] = {
30826 (char *) "pt", NULL
30827 };
30828
30829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30830 {
30831 arg1 = &temp1;
30832 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30833 }
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30837
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 resultobj = SWIG_From_int((int)(result));
30843 }
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30851 PyObject *resultobj;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 int result;
30854 PyObject * obj0 = 0 ;
30855 char *kwnames[] = {
30856 (char *) "window", NULL
30857 };
30858
30859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30861 if (SWIG_arg_fail(1)) SWIG_fail;
30862 {
30863 PyThreadState* __tstate = wxPyBeginAllowThreads();
30864 result = (int)Display_GetFromWindow(arg1);
30865
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 {
30870 resultobj = SWIG_From_int((int)(result));
30871 }
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30879 PyObject *resultobj;
30880 wxDisplay *arg1 = (wxDisplay *) 0 ;
30881 bool result;
30882 PyObject * obj0 = 0 ;
30883 char *kwnames[] = {
30884 (char *) "self", NULL
30885 };
30886
30887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30889 if (SWIG_arg_fail(1)) SWIG_fail;
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = (bool)((wxDisplay const *)arg1)->IsOk();
30893
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 {
30898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30899 }
30900 return resultobj;
30901 fail:
30902 return NULL;
30903 }
30904
30905
30906 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30907 PyObject *resultobj;
30908 wxDisplay *arg1 = (wxDisplay *) 0 ;
30909 wxRect result;
30910 PyObject * obj0 = 0 ;
30911 char *kwnames[] = {
30912 (char *) "self", NULL
30913 };
30914
30915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30917 if (SWIG_arg_fail(1)) SWIG_fail;
30918 {
30919 PyThreadState* __tstate = wxPyBeginAllowThreads();
30920 result = ((wxDisplay const *)arg1)->GetGeometry();
30921
30922 wxPyEndAllowThreads(__tstate);
30923 if (PyErr_Occurred()) SWIG_fail;
30924 }
30925 {
30926 wxRect * resultptr;
30927 resultptr = new wxRect((wxRect &)(result));
30928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30929 }
30930 return resultobj;
30931 fail:
30932 return NULL;
30933 }
30934
30935
30936 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30937 PyObject *resultobj;
30938 wxDisplay *arg1 = (wxDisplay *) 0 ;
30939 wxString result;
30940 PyObject * obj0 = 0 ;
30941 char *kwnames[] = {
30942 (char *) "self", NULL
30943 };
30944
30945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30947 if (SWIG_arg_fail(1)) SWIG_fail;
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 result = ((wxDisplay const *)arg1)->GetName();
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 {
30956 #if wxUSE_UNICODE
30957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30958 #else
30959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30960 #endif
30961 }
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj;
30970 wxDisplay *arg1 = (wxDisplay *) 0 ;
30971 bool result;
30972 PyObject * obj0 = 0 ;
30973 char *kwnames[] = {
30974 (char *) "self", NULL
30975 };
30976
30977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30979 if (SWIG_arg_fail(1)) SWIG_fail;
30980 {
30981 PyThreadState* __tstate = wxPyBeginAllowThreads();
30982 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30983
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 {
30988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30989 }
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30997 PyObject *resultobj;
30998 wxDisplay *arg1 = (wxDisplay *) 0 ;
30999 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31000 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31001 PyObject *result;
31002 PyObject * obj0 = 0 ;
31003 PyObject * obj1 = 0 ;
31004 char *kwnames[] = {
31005 (char *) "self",(char *) "mode", NULL
31006 };
31007
31008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
31009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31010 if (SWIG_arg_fail(1)) SWIG_fail;
31011 if (obj1) {
31012 {
31013 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31014 if (SWIG_arg_fail(2)) SWIG_fail;
31015 if (arg2 == NULL) {
31016 SWIG_null_ref("wxVideoMode");
31017 }
31018 if (SWIG_arg_fail(2)) SWIG_fail;
31019 }
31020 }
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
31024
31025 wxPyEndAllowThreads(__tstate);
31026 if (PyErr_Occurred()) SWIG_fail;
31027 }
31028 resultobj = result;
31029 return resultobj;
31030 fail:
31031 return NULL;
31032 }
31033
31034
31035 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31036 PyObject *resultobj;
31037 wxDisplay *arg1 = (wxDisplay *) 0 ;
31038 wxVideoMode result;
31039 PyObject * obj0 = 0 ;
31040 char *kwnames[] = {
31041 (char *) "self", NULL
31042 };
31043
31044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
31045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31046 if (SWIG_arg_fail(1)) SWIG_fail;
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31050
31051 wxPyEndAllowThreads(__tstate);
31052 if (PyErr_Occurred()) SWIG_fail;
31053 }
31054 {
31055 wxVideoMode * resultptr;
31056 resultptr = new wxVideoMode((wxVideoMode &)(result));
31057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31058 }
31059 return resultobj;
31060 fail:
31061 return NULL;
31062 }
31063
31064
31065 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31066 PyObject *resultobj;
31067 wxDisplay *arg1 = (wxDisplay *) 0 ;
31068 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31069 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31070 bool result;
31071 PyObject * obj0 = 0 ;
31072 PyObject * obj1 = 0 ;
31073 char *kwnames[] = {
31074 (char *) "self",(char *) "mode", NULL
31075 };
31076
31077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31079 if (SWIG_arg_fail(1)) SWIG_fail;
31080 if (obj1) {
31081 {
31082 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31083 if (SWIG_arg_fail(2)) SWIG_fail;
31084 if (arg2 == NULL) {
31085 SWIG_null_ref("wxVideoMode");
31086 }
31087 if (SWIG_arg_fail(2)) SWIG_fail;
31088 }
31089 }
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31093
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 {
31098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31099 }
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj;
31108 wxDisplay *arg1 = (wxDisplay *) 0 ;
31109 PyObject * obj0 = 0 ;
31110 char *kwnames[] = {
31111 (char *) "self", NULL
31112 };
31113
31114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31116 if (SWIG_arg_fail(1)) SWIG_fail;
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 (arg1)->ResetMode();
31120
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 Py_INCREF(Py_None); resultobj = Py_None;
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31132 PyObject *obj;
31133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31134 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31135 Py_INCREF(obj);
31136 return Py_BuildValue((char *)"");
31137 }
31138 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31139 PyObject *resultobj;
31140 wxStandardPaths *result;
31141 char *kwnames[] = {
31142 NULL
31143 };
31144
31145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = (wxStandardPaths *)StandardPaths_Get();
31149
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31161 PyObject *resultobj;
31162 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31163 wxString result;
31164 PyObject * obj0 = 0 ;
31165 char *kwnames[] = {
31166 (char *) "self", NULL
31167 };
31168
31169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31171 if (SWIG_arg_fail(1)) SWIG_fail;
31172 {
31173 PyThreadState* __tstate = wxPyBeginAllowThreads();
31174 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31175
31176 wxPyEndAllowThreads(__tstate);
31177 if (PyErr_Occurred()) SWIG_fail;
31178 }
31179 {
31180 #if wxUSE_UNICODE
31181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31182 #else
31183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31184 #endif
31185 }
31186 return resultobj;
31187 fail:
31188 return NULL;
31189 }
31190
31191
31192 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31193 PyObject *resultobj;
31194 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31195 wxString result;
31196 PyObject * obj0 = 0 ;
31197 char *kwnames[] = {
31198 (char *) "self", NULL
31199 };
31200
31201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31203 if (SWIG_arg_fail(1)) SWIG_fail;
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31207
31208 wxPyEndAllowThreads(__tstate);
31209 if (PyErr_Occurred()) SWIG_fail;
31210 }
31211 {
31212 #if wxUSE_UNICODE
31213 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31214 #else
31215 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31216 #endif
31217 }
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj;
31226 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31227 wxString result;
31228 PyObject * obj0 = 0 ;
31229 char *kwnames[] = {
31230 (char *) "self", NULL
31231 };
31232
31233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31235 if (SWIG_arg_fail(1)) SWIG_fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31239
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 {
31244 #if wxUSE_UNICODE
31245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31246 #else
31247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31248 #endif
31249 }
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31257 PyObject *resultobj;
31258 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31259 wxString result;
31260 PyObject * obj0 = 0 ;
31261 char *kwnames[] = {
31262 (char *) "self", NULL
31263 };
31264
31265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31267 if (SWIG_arg_fail(1)) SWIG_fail;
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31271
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 {
31276 #if wxUSE_UNICODE
31277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31278 #else
31279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31280 #endif
31281 }
31282 return resultobj;
31283 fail:
31284 return NULL;
31285 }
31286
31287
31288 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31289 PyObject *resultobj;
31290 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31291 wxString result;
31292 PyObject * obj0 = 0 ;
31293 char *kwnames[] = {
31294 (char *) "self", NULL
31295 };
31296
31297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31299 if (SWIG_arg_fail(1)) SWIG_fail;
31300 {
31301 PyThreadState* __tstate = wxPyBeginAllowThreads();
31302 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31303
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 {
31308 #if wxUSE_UNICODE
31309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31310 #else
31311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31312 #endif
31313 }
31314 return resultobj;
31315 fail:
31316 return NULL;
31317 }
31318
31319
31320 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31321 PyObject *resultobj;
31322 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31323 wxString result;
31324 PyObject * obj0 = 0 ;
31325 char *kwnames[] = {
31326 (char *) "self", NULL
31327 };
31328
31329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31331 if (SWIG_arg_fail(1)) SWIG_fail;
31332 {
31333 PyThreadState* __tstate = wxPyBeginAllowThreads();
31334 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31335
31336 wxPyEndAllowThreads(__tstate);
31337 if (PyErr_Occurred()) SWIG_fail;
31338 }
31339 {
31340 #if wxUSE_UNICODE
31341 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31342 #else
31343 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31344 #endif
31345 }
31346 return resultobj;
31347 fail:
31348 return NULL;
31349 }
31350
31351
31352 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31353 PyObject *resultobj;
31354 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31355 wxString result;
31356 PyObject * obj0 = 0 ;
31357 char *kwnames[] = {
31358 (char *) "self", NULL
31359 };
31360
31361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31363 if (SWIG_arg_fail(1)) SWIG_fail;
31364 {
31365 PyThreadState* __tstate = wxPyBeginAllowThreads();
31366 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31367
31368 wxPyEndAllowThreads(__tstate);
31369 if (PyErr_Occurred()) SWIG_fail;
31370 }
31371 {
31372 #if wxUSE_UNICODE
31373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31374 #else
31375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31376 #endif
31377 }
31378 return resultobj;
31379 fail:
31380 return NULL;
31381 }
31382
31383
31384 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31385 PyObject *resultobj;
31386 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31387 wxString *arg2 = 0 ;
31388 bool temp2 = false ;
31389 PyObject * obj0 = 0 ;
31390 PyObject * obj1 = 0 ;
31391 char *kwnames[] = {
31392 (char *) "self",(char *) "prefix", NULL
31393 };
31394
31395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31397 if (SWIG_arg_fail(1)) SWIG_fail;
31398 {
31399 arg2 = wxString_in_helper(obj1);
31400 if (arg2 == NULL) SWIG_fail;
31401 temp2 = true;
31402 }
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31406
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 Py_INCREF(Py_None); resultobj = Py_None;
31411 {
31412 if (temp2)
31413 delete arg2;
31414 }
31415 return resultobj;
31416 fail:
31417 {
31418 if (temp2)
31419 delete arg2;
31420 }
31421 return NULL;
31422 }
31423
31424
31425 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31426 PyObject *resultobj;
31427 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31428 wxString result;
31429 PyObject * obj0 = 0 ;
31430 char *kwnames[] = {
31431 (char *) "self", NULL
31432 };
31433
31434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31436 if (SWIG_arg_fail(1)) SWIG_fail;
31437 {
31438 PyThreadState* __tstate = wxPyBeginAllowThreads();
31439 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31440
31441 wxPyEndAllowThreads(__tstate);
31442 if (PyErr_Occurred()) SWIG_fail;
31443 }
31444 {
31445 #if wxUSE_UNICODE
31446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31447 #else
31448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31449 #endif
31450 }
31451 return resultobj;
31452 fail:
31453 return NULL;
31454 }
31455
31456
31457 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31458 PyObject *obj;
31459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31460 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31461 Py_INCREF(obj);
31462 return Py_BuildValue((char *)"");
31463 }
31464 static PyMethodDef SwigMethods[] = {
31465 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31472 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31480 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"LaunchDefaultBrowser", (PyCFunction) _wrap_LaunchDefaultBrowser, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31545 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31553 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31571 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31574 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31577 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31580 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31586 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31600 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31606 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31612 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31615 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31629 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31632 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31633 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31636 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31663 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31665 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31667 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31669 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31676 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31682 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31696 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31700 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31703 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31720 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31728 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31775 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31793 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31803 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31819 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31835 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31849 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31859 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31902 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31905 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31908 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31912 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
32005 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
32006 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
32007 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
32008 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
32025 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32070 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32104 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32112 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32113 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32118 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32127 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32134 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32137 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32140 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32145 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32148 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32152 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32155 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32159 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32160 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32164 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32168 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32170 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32180 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32186 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32190 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32193 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32201 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32208 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32209 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32222 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32223 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32227 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32233 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32234 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32235 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32236 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32237 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32238 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32239 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32240 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32241 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32242 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32243 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32244 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32245 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32246 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32247 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32248 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32249 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32250 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32251 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32252 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32253 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32254 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32255 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32256 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32257 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32258 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32259 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32260 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32261 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32262 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32263 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32264 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32265 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32266 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32267 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32268 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32269 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32270 { NULL, NULL, 0, NULL }
32271 };
32272
32273
32274 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32275
32276 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32277 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32278 }
32279 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32280 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32281 }
32282 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32283 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32284 }
32285 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32286 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32287 }
32288 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32289 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32290 }
32291 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32292 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32293 }
32294 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32295 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32296 }
32297 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32298 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32299 }
32300 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32301 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32302 }
32303 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32304 return (void *)((wxEvent *) ((wxPyEvent *) x));
32305 }
32306 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32307 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32308 }
32309 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32310 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32311 }
32312 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32313 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32314 }
32315 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32316 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32317 }
32318 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32319 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32320 }
32321 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32322 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32323 }
32324 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32325 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32326 }
32327 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32328 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32329 }
32330 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32331 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32332 }
32333 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32334 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32335 }
32336 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32337 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32338 }
32339 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32340 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32341 }
32342 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32343 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32344 }
32345 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32346 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32347 }
32348 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32349 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32350 }
32351 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32352 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32353 }
32354 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32355 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32356 }
32357 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32358 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32359 }
32360 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32361 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32362 }
32363 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32364 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32365 }
32366 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32367 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32368 }
32369 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32370 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32371 }
32372 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32373 return (void *)((wxEvent *) ((wxShowEvent *) x));
32374 }
32375 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32376 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32377 }
32378 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32379 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32380 }
32381 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32382 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32383 }
32384 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32385 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32386 }
32387 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32388 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32389 }
32390 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32391 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32392 }
32393 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32394 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32395 }
32396 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32397 return (void *)((wxConfigBase *) ((wxConfig *) x));
32398 }
32399 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32400 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32401 }
32402 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32403 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32404 }
32405 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32406 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32407 }
32408 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32409 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32410 }
32411 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32412 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32413 }
32414 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32415 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32416 }
32417 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32418 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32419 }
32420 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32421 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32422 }
32423 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32424 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32425 }
32426 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32427 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32428 }
32429 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32430 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32431 }
32432 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32433 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32434 }
32435 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32436 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32437 }
32438 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32439 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32440 }
32441 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32442 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32443 }
32444 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32445 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32446 }
32447 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32448 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32449 }
32450 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32451 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32452 }
32453 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32454 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32455 }
32456 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32457 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32458 }
32459 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32460 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32461 }
32462 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32463 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32464 }
32465 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32466 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32467 }
32468 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32469 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32470 }
32471 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32472 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32473 }
32474 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32475 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32476 }
32477 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32478 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32479 }
32480 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32481 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32482 }
32483 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32484 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32485 }
32486 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32487 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32488 }
32489 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32490 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32491 }
32492 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32493 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32494 }
32495 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32496 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32497 }
32498 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32499 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32500 }
32501 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32502 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32503 }
32504 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32505 return (void *)((wxObject *) ((wxSizerItem *) x));
32506 }
32507 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32508 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32509 }
32510 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32511 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32512 }
32513 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32514 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32515 }
32516 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32517 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32518 }
32519 static void *_p_wxSizerTo_p_wxObject(void *x) {
32520 return (void *)((wxObject *) ((wxSizer *) x));
32521 }
32522 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32523 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32524 }
32525 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32526 return (void *)((wxObject *) ((wxFileHistory *) x));
32527 }
32528 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32530 }
32531 static void *_p_wxEventTo_p_wxObject(void *x) {
32532 return (void *)((wxObject *) ((wxEvent *) x));
32533 }
32534 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32535 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32536 }
32537 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32538 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32539 }
32540 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32541 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32542 }
32543 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32544 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32545 }
32546 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32547 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32548 }
32549 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32550 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32551 }
32552 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32553 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32554 }
32555 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32556 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32557 }
32558 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32559 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32560 }
32561 static void *_p_wxControlTo_p_wxObject(void *x) {
32562 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32563 }
32564 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32565 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32566 }
32567 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32568 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32569 }
32570 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32571 return (void *)((wxObject *) ((wxFSFile *) x));
32572 }
32573 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32574 return (void *)((wxObject *) ((wxClipboard *) x));
32575 }
32576 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32577 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32578 }
32579 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32580 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32581 }
32582 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32583 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32584 }
32585 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32586 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32587 }
32588 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32589 return (void *)((wxObject *) ((wxToolTip *) x));
32590 }
32591 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) ((wxMenuItem *) x));
32593 }
32594 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32596 }
32597 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32599 }
32600 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32602 }
32603 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32605 }
32606 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32608 }
32609 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32611 }
32612 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32614 }
32615 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32617 }
32618 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32620 }
32621 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32623 }
32624 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32626 }
32627 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32629 }
32630 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32632 }
32633 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32635 }
32636 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32637 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32638 }
32639 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32640 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32641 }
32642 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32643 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32644 }
32645 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32646 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32647 }
32648 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32649 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32650 }
32651 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32652 return (void *)((wxObject *) ((wxImageHandler *) x));
32653 }
32654 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32655 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32656 }
32657 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32658 return (void *)((wxObject *) ((wxEvtHandler *) x));
32659 }
32660 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32661 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32662 }
32663 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32664 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32665 }
32666 static void *_p_wxImageTo_p_wxObject(void *x) {
32667 return (void *)((wxObject *) ((wxImage *) x));
32668 }
32669 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32670 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32671 }
32672 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32673 return (void *)((wxObject *) ((wxSystemOptions *) x));
32674 }
32675 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32676 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32677 }
32678 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32679 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32680 }
32681 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32682 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32683 }
32684 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32685 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32686 }
32687 static void *_p_wxWindowTo_p_wxObject(void *x) {
32688 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32689 }
32690 static void *_p_wxMenuTo_p_wxObject(void *x) {
32691 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32692 }
32693 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32694 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32695 }
32696 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32697 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32698 }
32699 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32700 return (void *)((wxObject *) ((wxFileSystem *) x));
32701 }
32702 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32703 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32704 }
32705 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32706 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32707 }
32708 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32709 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32710 }
32711 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32712 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32713 }
32714 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32715 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32716 }
32717 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32718 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32719 }
32720 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32721 return (void *)((wxObject *) ((wxBusyInfo *) x));
32722 }
32723 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32724 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32725 }
32726 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32727 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32728 }
32729 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32730 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32731 }
32732 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32733 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32734 }
32735 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32736 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32737 }
32738 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32739 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32740 }
32741 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32742 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32743 }
32744 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32745 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32746 }
32747 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32748 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32749 }
32750 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32751 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32752 }
32753 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32754 return (void *)((wxLog *) ((wxLogStderr *) x));
32755 }
32756 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32757 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32758 }
32759 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32760 return (void *)((wxLog *) ((wxLogWindow *) x));
32761 }
32762 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32763 return (void *)((wxLog *) ((wxLogChain *) x));
32764 }
32765 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32766 return (void *)((wxLog *) ((wxLogGui *) x));
32767 }
32768 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32769 return (void *)((wxLog *) ((wxPyLog *) x));
32770 }
32771 static void *_p_wxControlTo_p_wxWindow(void *x) {
32772 return (void *)((wxWindow *) ((wxControl *) x));
32773 }
32774 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32775 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32776 }
32777 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32778 return (void *)((wxWindow *) ((wxMenuBar *) x));
32779 }
32780 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32781 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32782 }
32783 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32784 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32785 }
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803 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}};
32804 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}};
32805 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}};
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845 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}};
32846 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}};
32847 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}};
32848 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}};
32849 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}};
32850 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}};
32851 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}};
32852 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}};
32853 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}};
32854 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}};
32855 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}};
32856 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}};
32857 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}};
32858 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}};
32859 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}};
32860 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}};
32861 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}};
32862 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}};
32863 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}};
32864 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}};
32865 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}};
32866 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}};
32867 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}};
32868 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}};
32869 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}};
32870 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}};
32871 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}};
32872 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}};
32873 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}};
32874 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}};
32875 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}};
32876 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}};
32877 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}};
32878 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}};
32879 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}};
32880 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}};
32881 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}};
32882
32883 static swig_type_info *swig_types_initial[] = {
32884 _swigt__p_wxLogChain,
32885 _swigt__p_wxMutexGuiLocker,
32886 _swigt__p_wxFileHistory,
32887 _swigt__p_wxLog,
32888 _swigt__p_wxMenu,
32889 _swigt__p_wxEvent,
32890 _swigt__p_wxDateTime__TimeZone,
32891 _swigt__p_wxConfigBase,
32892 _swigt__p_wxDisplay,
32893 _swigt__p_wxFileType,
32894 _swigt__p_wxLogGui,
32895 _swigt__p_wxFont,
32896 _swigt__p_wxDataFormat,
32897 _swigt__p_wxTimerEvent,
32898 _swigt__p_wxCaret,
32899 _swigt__ptrdiff_t,
32900 _swigt__std__ptrdiff_t,
32901 _swigt__p_int,
32902 _swigt__p_wxSize,
32903 _swigt__p_wxClipboard,
32904 _swigt__p_wxStopWatch,
32905 _swigt__p_wxDC,
32906 _swigt__p_wxClipboardLocker,
32907 _swigt__p_wxIcon,
32908 _swigt__p_wxLogStderr,
32909 _swigt__p_wxLogTextCtrl,
32910 _swigt__p_wxTextCtrl,
32911 _swigt__p_wxBusyCursor,
32912 _swigt__p_wxBitmapDataObject,
32913 _swigt__p_wxTextDataObject,
32914 _swigt__p_wxDataObject,
32915 _swigt__p_wxPyTextDataObject,
32916 _swigt__p_wxPyBitmapDataObject,
32917 _swigt__p_wxFileDataObject,
32918 _swigt__p_wxCustomDataObject,
32919 _swigt__p_wxURLDataObject,
32920 _swigt__p_wxMetafileDataObject,
32921 _swigt__p_wxSound,
32922 _swigt__p_wxTimerRunner,
32923 _swigt__p_wxLogWindow,
32924 _swigt__p_wxTimeSpan,
32925 _swigt__p_wxArrayString,
32926 _swigt__p_wxWindowDisabler,
32927 _swigt__p_form_ops_t,
32928 _swigt__p_wxToolTip,
32929 _swigt__p_wxDataObjectComposite,
32930 _swigt__p_wxSystemSettings,
32931 _swigt__p_wxFileConfig,
32932 _swigt__p_wxVideoMode,
32933 _swigt__p_wxDataObjectSimple,
32934 _swigt__p_wxPyDataObjectSimple,
32935 _swigt__p_wxDuplexMode,
32936 _swigt__p_wxEvtHandler,
32937 _swigt__p_wxRect,
32938 _swigt__p_char,
32939 _swigt__p_wxSingleInstanceChecker,
32940 _swigt__p_wxStandardPaths,
32941 _swigt__p_wxFileTypeInfo,
32942 _swigt__p_wxFrame,
32943 _swigt__p_wxTimer,
32944 _swigt__p_wxPaperSize,
32945 _swigt__p_wxMimeTypesManager,
32946 _swigt__p_wxPyArtProvider,
32947 _swigt__p_wxPyTipProvider,
32948 _swigt__p_wxTipProvider,
32949 _swigt__p_wxJoystick,
32950 _swigt__p_wxSystemOptions,
32951 _swigt__p_wxPoint,
32952 _swigt__p_wxJoystickEvent,
32953 _swigt__p_wxCursor,
32954 _swigt__p_wxObject,
32955 _swigt__p_wxOutputStream,
32956 _swigt__p_wxDateTime,
32957 _swigt__p_wxPyDropSource,
32958 _swigt__p_unsigned_long,
32959 _swigt__p_wxKillError,
32960 _swigt__p_wxWindow,
32961 _swigt__p_wxString,
32962 _swigt__p_wxPyProcess,
32963 _swigt__p_wxBitmap,
32964 _swigt__p_wxConfig,
32965 _swigt__unsigned_int,
32966 _swigt__p_unsigned_int,
32967 _swigt__p_unsigned_char,
32968 _swigt__p_wxChar,
32969 _swigt__p_wxBusyInfo,
32970 _swigt__p_wxPyDropTarget,
32971 _swigt__p_wxPyTextDropTarget,
32972 _swigt__p_wxPyFileDropTarget,
32973 _swigt__p_wxProcessEvent,
32974 _swigt__p_wxPyLog,
32975 _swigt__p_wxLogNull,
32976 _swigt__p_wxColour,
32977 _swigt__p_wxPyTimer,
32978 _swigt__p_wxConfigPathChanger,
32979 _swigt__p_wxDateSpan,
32980 0
32981 };
32982
32983
32984 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32985
32986 static swig_const_info swig_const_table[] = {
32987 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32988 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32989 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32990 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32991 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32992 {0, 0, 0, 0.0, 0, 0}};
32993
32994 #ifdef __cplusplus
32995 }
32996 #endif
32997
32998
32999 #ifdef __cplusplus
33000 extern "C" {
33001 #endif
33002
33003 /* Python-specific SWIG API */
33004 #define SWIG_newvarlink() SWIG_Python_newvarlink()
33005 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
33006 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
33007
33008 /* -----------------------------------------------------------------------------
33009 * global variable support code.
33010 * ----------------------------------------------------------------------------- */
33011
33012 typedef struct swig_globalvar {
33013 char *name; /* Name of global variable */
33014 PyObject *(*get_attr)(); /* Return the current value */
33015 int (*set_attr)(PyObject *); /* Set the value */
33016 struct swig_globalvar *next;
33017 } swig_globalvar;
33018
33019 typedef struct swig_varlinkobject {
33020 PyObject_HEAD
33021 swig_globalvar *vars;
33022 } swig_varlinkobject;
33023
33024 static PyObject *
33025 swig_varlink_repr(swig_varlinkobject *v) {
33026 v = v;
33027 return PyString_FromString("<Swig global variables>");
33028 }
33029
33030 static int
33031 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
33032 swig_globalvar *var;
33033 flags = flags;
33034 fprintf(fp,"Swig global variables { ");
33035 for (var = v->vars; var; var=var->next) {
33036 fprintf(fp,"%s", var->name);
33037 if (var->next) fprintf(fp,", ");
33038 }
33039 fprintf(fp," }\n");
33040 return 0;
33041 }
33042
33043 static PyObject *
33044 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33045 swig_globalvar *var = v->vars;
33046 while (var) {
33047 if (strcmp(var->name,n) == 0) {
33048 return (*var->get_attr)();
33049 }
33050 var = var->next;
33051 }
33052 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33053 return NULL;
33054 }
33055
33056 static int
33057 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33058 swig_globalvar *var = v->vars;
33059 while (var) {
33060 if (strcmp(var->name,n) == 0) {
33061 return (*var->set_attr)(p);
33062 }
33063 var = var->next;
33064 }
33065 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33066 return 1;
33067 }
33068
33069 static PyTypeObject varlinktype = {
33070 PyObject_HEAD_INIT(0)
33071 0, /* Number of items in variable part (ob_size) */
33072 (char *)"swigvarlink", /* Type name (tp_name) */
33073 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33074 0, /* Itemsize (tp_itemsize) */
33075 0, /* Deallocator (tp_dealloc) */
33076 (printfunc) swig_varlink_print, /* Print (tp_print) */
33077 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33078 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33079 0, /* tp_compare */
33080 (reprfunc) swig_varlink_repr, /* tp_repr */
33081 0, /* tp_as_number */
33082 0, /* tp_as_sequence */
33083 0, /* tp_as_mapping */
33084 0, /* tp_hash */
33085 0, /* tp_call */
33086 0, /* tp_str */
33087 0, /* tp_getattro */
33088 0, /* tp_setattro */
33089 0, /* tp_as_buffer */
33090 0, /* tp_flags */
33091 0, /* tp_doc */
33092 #if PY_VERSION_HEX >= 0x02000000
33093 0, /* tp_traverse */
33094 0, /* tp_clear */
33095 #endif
33096 #if PY_VERSION_HEX >= 0x02010000
33097 0, /* tp_richcompare */
33098 0, /* tp_weaklistoffset */
33099 #endif
33100 #if PY_VERSION_HEX >= 0x02020000
33101 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33102 #endif
33103 #if PY_VERSION_HEX >= 0x02030000
33104 0, /* tp_del */
33105 #endif
33106 #ifdef COUNT_ALLOCS
33107 0,0,0,0 /* tp_alloc -> tp_next */
33108 #endif
33109 };
33110
33111 /* Create a variable linking object for use later */
33112 static PyObject *
33113 SWIG_Python_newvarlink(void) {
33114 swig_varlinkobject *result = 0;
33115 result = PyMem_NEW(swig_varlinkobject,1);
33116 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33117 result->ob_type = &varlinktype;
33118 result->vars = 0;
33119 result->ob_refcnt = 0;
33120 Py_XINCREF((PyObject *) result);
33121 return ((PyObject*) result);
33122 }
33123
33124 static void
33125 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33126 swig_varlinkobject *v;
33127 swig_globalvar *gv;
33128 v= (swig_varlinkobject *) p;
33129 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33130 gv->name = (char *) malloc(strlen(name)+1);
33131 strcpy(gv->name,name);
33132 gv->get_attr = get_attr;
33133 gv->set_attr = set_attr;
33134 gv->next = v->vars;
33135 v->vars = gv;
33136 }
33137
33138 /* -----------------------------------------------------------------------------
33139 * constants/methods manipulation
33140 * ----------------------------------------------------------------------------- */
33141
33142 /* Install Constants */
33143 static void
33144 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33145 PyObject *obj = 0;
33146 size_t i;
33147 for (i = 0; constants[i].type; i++) {
33148 switch(constants[i].type) {
33149 case SWIG_PY_INT:
33150 obj = PyInt_FromLong(constants[i].lvalue);
33151 break;
33152 case SWIG_PY_FLOAT:
33153 obj = PyFloat_FromDouble(constants[i].dvalue);
33154 break;
33155 case SWIG_PY_STRING:
33156 if (constants[i].pvalue) {
33157 obj = PyString_FromString((char *) constants[i].pvalue);
33158 } else {
33159 Py_INCREF(Py_None);
33160 obj = Py_None;
33161 }
33162 break;
33163 case SWIG_PY_POINTER:
33164 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33165 break;
33166 case SWIG_PY_BINARY:
33167 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33168 break;
33169 default:
33170 obj = 0;
33171 break;
33172 }
33173 if (obj) {
33174 PyDict_SetItemString(d,constants[i].name,obj);
33175 Py_DECREF(obj);
33176 }
33177 }
33178 }
33179
33180 /* -----------------------------------------------------------------------------*/
33181 /* Fix SwigMethods to carry the callback ptrs when needed */
33182 /* -----------------------------------------------------------------------------*/
33183
33184 static void
33185 SWIG_Python_FixMethods(PyMethodDef *methods,
33186 swig_const_info *const_table,
33187 swig_type_info **types,
33188 swig_type_info **types_initial) {
33189 size_t i;
33190 for (i = 0; methods[i].ml_name; ++i) {
33191 char *c = methods[i].ml_doc;
33192 if (c && (c = strstr(c, "swig_ptr: "))) {
33193 int j;
33194 swig_const_info *ci = 0;
33195 char *name = c + 10;
33196 for (j = 0; const_table[j].type; j++) {
33197 if (strncmp(const_table[j].name, name,
33198 strlen(const_table[j].name)) == 0) {
33199 ci = &(const_table[j]);
33200 break;
33201 }
33202 }
33203 if (ci) {
33204 size_t shift = (ci->ptype) - types;
33205 swig_type_info *ty = types_initial[shift];
33206 size_t ldoc = (c - methods[i].ml_doc);
33207 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33208 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33209 char *buff = ndoc;
33210 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33211 strncpy(buff, methods[i].ml_doc, ldoc);
33212 buff += ldoc;
33213 strncpy(buff, "swig_ptr: ", 10);
33214 buff += 10;
33215 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33216 methods[i].ml_doc = ndoc;
33217 }
33218 }
33219 }
33220 }
33221
33222 /* -----------------------------------------------------------------------------*
33223 * Initialize type list
33224 * -----------------------------------------------------------------------------*/
33225
33226 #if PY_MAJOR_VERSION < 2
33227 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33228 is copied out of Python/modsupport.c in python version 2.3.4 */
33229 static int
33230 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33231 {
33232 PyObject *dict;
33233 if (!PyModule_Check(m)) {
33234 PyErr_SetString(PyExc_TypeError,
33235 "PyModule_AddObject() needs module as first arg");
33236 return -1;
33237 }
33238 if (!o) {
33239 PyErr_SetString(PyExc_TypeError,
33240 "PyModule_AddObject() needs non-NULL value");
33241 return -1;
33242 }
33243
33244 dict = PyModule_GetDict(m);
33245 if (dict == NULL) {
33246 /* Internal error -- modules must have a dict! */
33247 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33248 PyModule_GetName(m));
33249 return -1;
33250 }
33251 if (PyDict_SetItemString(dict, name, o))
33252 return -1;
33253 Py_DECREF(o);
33254 return 0;
33255 }
33256 #endif
33257
33258 static swig_type_info **
33259 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33260 static PyMethodDef swig_empty_runtime_method_table[] = {
33261 {
33262 NULL, NULL, 0, NULL
33263 }
33264 };/* Sentinel */
33265
33266 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33267 swig_empty_runtime_method_table);
33268 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33269 if (pointer && module) {
33270 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33271 }
33272 return type_list_handle;
33273 }
33274
33275 static swig_type_info **
33276 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33277 swig_type_info **type_pointer;
33278
33279 /* first check if module already created */
33280 type_pointer = SWIG_Python_GetTypeListHandle();
33281 if (type_pointer) {
33282 return type_pointer;
33283 } else {
33284 /* create a new module and variable */
33285 return SWIG_Python_SetTypeListHandle(type_list_handle);
33286 }
33287 }
33288
33289 #ifdef __cplusplus
33290 }
33291 #endif
33292
33293 /* -----------------------------------------------------------------------------*
33294 * Partial Init method
33295 * -----------------------------------------------------------------------------*/
33296
33297 #ifdef SWIG_LINK_RUNTIME
33298 #ifdef __cplusplus
33299 extern "C"
33300 #endif
33301 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33302 #endif
33303
33304 #ifdef __cplusplus
33305 extern "C"
33306 #endif
33307 SWIGEXPORT(void) SWIG_init(void) {
33308 static PyObject *SWIG_globals = 0;
33309 static int typeinit = 0;
33310 PyObject *m, *d;
33311 int i;
33312 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33313
33314 /* Fix SwigMethods to carry the callback ptrs when needed */
33315 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33316
33317 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33318 d = PyModule_GetDict(m);
33319
33320 if (!typeinit) {
33321 #ifdef SWIG_LINK_RUNTIME
33322 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33323 #else
33324 # ifndef SWIG_STATIC_RUNTIME
33325 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33326 # endif
33327 #endif
33328 for (i = 0; swig_types_initial[i]; i++) {
33329 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33330 }
33331 typeinit = 1;
33332 }
33333 SWIG_InstallConstants(d,swig_const_table);
33334
33335 {
33336 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33580 }
33581 {
33582 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33583 }
33584 {
33585 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33604 }
33605 {
33606 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33607 }
33608 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33609 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33610 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33611 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33612 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33613 {
33614 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33624 }
33625 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33626
33627 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33628
33629 {
33630 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33631 }
33632 {
33633 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33634 }
33635 {
33636 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33637 }
33638 {
33639 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33640 }
33641 {
33642 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33643 }
33644 {
33645 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33646 }
33647 {
33648 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33661 }
33662 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33663 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33664 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33665 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33666 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33667 {
33668 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33684 }
33685 {
33686 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33687 }
33688 {
33689 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33690 }
33691 {
33692 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33693 }
33694 {
33695 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33696 }
33697 {
33698 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33699 }
33700 {
33701 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33702 }
33703 {
33704 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33705 }
33706 {
33707 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33708 }
33709 {
33710 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33711 }
33712 {
33713 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33714 }
33715 {
33716 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33717 }
33718 {
33719 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33720 }
33721 {
33722 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33759 }
33760 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33761 {
33762 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33763 }
33764 {
33765 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33766 }
33767 {
33768 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33775 }
33776
33777 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33778
33779 {
33780 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33799 }
33800 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33801 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33802 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33803 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33804 {
33805 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33827 }
33828 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33830 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33831 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33832 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33833 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33834 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33835 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33837 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33838 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33839 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33840 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33841 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33842 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33843 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33844 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33845 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33846 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33847 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33848 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33849 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33850 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33851 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33852 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33853 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33854 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33855 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33856 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33857 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33858 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33859 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33860 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33861 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33862 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33863 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33864 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33865 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33866 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33867 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33868 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33869 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33870 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33871 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33872 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33873 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33874 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33875 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33876 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33877 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33879 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33880 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33881 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33882 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33883 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33884
33885 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33886
33887 {
33888 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33889 }
33890 {
33891 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33892 }
33893 {
33894 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33895 }
33896 {
33897 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33898 }
33899 {
33900 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33901 }
33902 {
33903 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33904 }
33905 {
33906 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33907 }
33908 {
33909 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33910 }
33911 {
33912 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33913 }
33914 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33915 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33916 {
33917 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34326 }
34327 {
34328 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34329 }
34330 {
34331 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34332 }
34333 {
34334 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34335 }
34336 {
34337 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34338 }
34339 {
34340 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34341 }
34342 {
34343 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34344 }
34345 {
34346 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34380 }
34381 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34382 {
34383 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34384 }
34385 {
34386 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34387 }
34388 {
34389 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34390 }
34391 {
34392 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34393 }
34394 {
34395 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34396 }
34397 {
34398 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34399 }
34400 {
34401 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34402 }
34403 {
34404 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34405 }
34406 {
34407 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34423 }
34424 {
34425 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34426 }
34427 {
34428 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34429 }
34430 {
34431 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34432 }
34433 {
34434 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34435 }
34436 {
34437 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34438 }
34439 {
34440 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34441 }
34442 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34443 {
34444 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34445 }
34446 {
34447 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34448 }
34449 {
34450 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34451 }
34452 {
34453 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34454 }
34455 {
34456 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34457 }
34458 {
34459 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34460 }
34461 {
34462 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34463 }
34464 {
34465 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34466 }
34467 {
34468 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34469 }
34470 {
34471 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34472 }
34473 {
34474 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34475 }
34476 {
34477 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34478 }
34479
34480 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34481 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34482 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34483 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34484
34485 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34486 }
34487
wxWidgets (Impactor)