]> 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
Add support for launching APPL bundles with wxExecute
[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_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj;
6021 wxKeyCode arg1 ;
6022 bool result;
6023 PyObject * obj0 = 0 ;
6024 char *kwnames[] = {
6025 (char *) "key", NULL
6026 };
6027
6028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
6029 {
6030 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
6031 if (SWIG_arg_fail(1)) SWIG_fail;
6032 }
6033 {
6034 if (!wxPyCheckForApp()) SWIG_fail;
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 result = (bool)wxGetKeyState((wxKeyCode )arg1);
6037
6038 wxPyEndAllowThreads(__tstate);
6039 if (PyErr_Occurred()) SWIG_fail;
6040 }
6041 {
6042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6043 }
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 char *kwnames[] = {
6053 NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6057 {
6058 if (!wxPyCheckForApp()) SWIG_fail;
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 wxWakeUpMainThread();
6061
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 Py_INCREF(Py_None); resultobj = Py_None;
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj;
6074 char *kwnames[] = {
6075 NULL
6076 };
6077
6078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6079 {
6080 if (!wxPyCheckForApp()) SWIG_fail;
6081 PyThreadState* __tstate = wxPyBeginAllowThreads();
6082 wxMutexGuiEnter();
6083
6084 wxPyEndAllowThreads(__tstate);
6085 if (PyErr_Occurred()) SWIG_fail;
6086 }
6087 Py_INCREF(Py_None); resultobj = Py_None;
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 char *kwnames[] = {
6097 NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6101 {
6102 if (!wxPyCheckForApp()) SWIG_fail;
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 wxMutexGuiLeave();
6105
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 Py_INCREF(Py_None); resultobj = Py_None;
6110 return resultobj;
6111 fail:
6112 return NULL;
6113 }
6114
6115
6116 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6117 PyObject *resultobj;
6118 wxMutexGuiLocker *result;
6119 char *kwnames[] = {
6120 NULL
6121 };
6122
6123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6124 {
6125 if (!wxPyCheckForApp()) SWIG_fail;
6126 PyThreadState* __tstate = wxPyBeginAllowThreads();
6127 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6128
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6142 PyObject * obj0 = 0 ;
6143 char *kwnames[] = {
6144 (char *) "self", NULL
6145 };
6146
6147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6149 if (SWIG_arg_fail(1)) SWIG_fail;
6150 {
6151 PyThreadState* __tstate = wxPyBeginAllowThreads();
6152 delete arg1;
6153
6154 wxPyEndAllowThreads(__tstate);
6155 if (PyErr_Occurred()) SWIG_fail;
6156 }
6157 Py_INCREF(Py_None); resultobj = Py_None;
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6165 PyObject *obj;
6166 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6167 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6168 Py_INCREF(obj);
6169 return Py_BuildValue((char *)"");
6170 }
6171 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj;
6173 bool result;
6174 char *kwnames[] = {
6175 NULL
6176 };
6177
6178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6179 {
6180 PyThreadState* __tstate = wxPyBeginAllowThreads();
6181 result = (bool)wxThread_IsMain();
6182
6183 wxPyEndAllowThreads(__tstate);
6184 if (PyErr_Occurred()) SWIG_fail;
6185 }
6186 {
6187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6188 }
6189 return resultobj;
6190 fail:
6191 return NULL;
6192 }
6193
6194
6195 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6196 PyObject *resultobj;
6197 wxString *arg1 = 0 ;
6198 wxToolTip *result;
6199 bool temp1 = false ;
6200 PyObject * obj0 = 0 ;
6201 char *kwnames[] = {
6202 (char *) "tip", NULL
6203 };
6204
6205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6206 {
6207 arg1 = wxString_in_helper(obj0);
6208 if (arg1 == NULL) SWIG_fail;
6209 temp1 = true;
6210 }
6211 {
6212 if (!wxPyCheckForApp()) SWIG_fail;
6213 PyThreadState* __tstate = wxPyBeginAllowThreads();
6214 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6215
6216 wxPyEndAllowThreads(__tstate);
6217 if (PyErr_Occurred()) SWIG_fail;
6218 }
6219 {
6220 resultobj = wxPyMake_wxObject(result, 1);
6221 }
6222 {
6223 if (temp1)
6224 delete arg1;
6225 }
6226 return resultobj;
6227 fail:
6228 {
6229 if (temp1)
6230 delete arg1;
6231 }
6232 return NULL;
6233 }
6234
6235
6236 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6237 PyObject *resultobj;
6238 wxToolTip *arg1 = (wxToolTip *) 0 ;
6239 wxString *arg2 = 0 ;
6240 bool temp2 = false ;
6241 PyObject * obj0 = 0 ;
6242 PyObject * obj1 = 0 ;
6243 char *kwnames[] = {
6244 (char *) "self",(char *) "tip", NULL
6245 };
6246
6247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6249 if (SWIG_arg_fail(1)) SWIG_fail;
6250 {
6251 arg2 = wxString_in_helper(obj1);
6252 if (arg2 == NULL) SWIG_fail;
6253 temp2 = true;
6254 }
6255 {
6256 PyThreadState* __tstate = wxPyBeginAllowThreads();
6257 (arg1)->SetTip((wxString const &)*arg2);
6258
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 Py_INCREF(Py_None); resultobj = Py_None;
6263 {
6264 if (temp2)
6265 delete arg2;
6266 }
6267 return resultobj;
6268 fail:
6269 {
6270 if (temp2)
6271 delete arg2;
6272 }
6273 return NULL;
6274 }
6275
6276
6277 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6278 PyObject *resultobj;
6279 wxToolTip *arg1 = (wxToolTip *) 0 ;
6280 wxString result;
6281 PyObject * obj0 = 0 ;
6282 char *kwnames[] = {
6283 (char *) "self", NULL
6284 };
6285
6286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6288 if (SWIG_arg_fail(1)) SWIG_fail;
6289 {
6290 PyThreadState* __tstate = wxPyBeginAllowThreads();
6291 result = (arg1)->GetTip();
6292
6293 wxPyEndAllowThreads(__tstate);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 {
6297 #if wxUSE_UNICODE
6298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6299 #else
6300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6301 #endif
6302 }
6303 return resultobj;
6304 fail:
6305 return NULL;
6306 }
6307
6308
6309 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6310 PyObject *resultobj;
6311 wxToolTip *arg1 = (wxToolTip *) 0 ;
6312 wxWindow *result;
6313 PyObject * obj0 = 0 ;
6314 char *kwnames[] = {
6315 (char *) "self", NULL
6316 };
6317
6318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6320 if (SWIG_arg_fail(1)) SWIG_fail;
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 result = (wxWindow *)(arg1)->GetWindow();
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 {
6329 resultobj = wxPyMake_wxObject(result, 0);
6330 }
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 bool arg1 ;
6340 PyObject * obj0 = 0 ;
6341 char *kwnames[] = {
6342 (char *) "flag", NULL
6343 };
6344
6345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6346 {
6347 arg1 = (bool)(SWIG_As_bool(obj0));
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 }
6350 {
6351 PyThreadState* __tstate = wxPyBeginAllowThreads();
6352 wxToolTip::Enable(arg1);
6353
6354 wxPyEndAllowThreads(__tstate);
6355 if (PyErr_Occurred()) SWIG_fail;
6356 }
6357 Py_INCREF(Py_None); resultobj = Py_None;
6358 return resultobj;
6359 fail:
6360 return NULL;
6361 }
6362
6363
6364 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6365 PyObject *resultobj;
6366 long arg1 ;
6367 PyObject * obj0 = 0 ;
6368 char *kwnames[] = {
6369 (char *) "milliseconds", NULL
6370 };
6371
6372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6373 {
6374 arg1 = (long)(SWIG_As_long(obj0));
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 }
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 wxToolTip::SetDelay(arg1);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 Py_INCREF(Py_None); resultobj = Py_None;
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6392 PyObject *obj;
6393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6394 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6395 Py_INCREF(obj);
6396 return Py_BuildValue((char *)"");
6397 }
6398 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6399 PyObject *resultobj;
6400 wxWindow *arg1 = (wxWindow *) 0 ;
6401 wxSize *arg2 = 0 ;
6402 wxCaret *result;
6403 wxSize temp2 ;
6404 PyObject * obj0 = 0 ;
6405 PyObject * obj1 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "window",(char *) "size", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 arg2 = &temp2;
6415 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6416 }
6417 {
6418 if (!wxPyCheckForApp()) SWIG_fail;
6419 PyThreadState* __tstate = wxPyBeginAllowThreads();
6420 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6421
6422 wxPyEndAllowThreads(__tstate);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj;
6434 wxCaret *arg1 = (wxCaret *) 0 ;
6435 PyObject * obj0 = 0 ;
6436 char *kwnames[] = {
6437 (char *) "self", NULL
6438 };
6439
6440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6442 if (SWIG_arg_fail(1)) SWIG_fail;
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 wxCaret_Destroy(arg1);
6446
6447 wxPyEndAllowThreads(__tstate);
6448 if (PyErr_Occurred()) SWIG_fail;
6449 }
6450 Py_INCREF(Py_None); resultobj = Py_None;
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxCaret *arg1 = (wxCaret *) 0 ;
6460 bool result;
6461 PyObject * obj0 = 0 ;
6462 char *kwnames[] = {
6463 (char *) "self", NULL
6464 };
6465
6466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6468 if (SWIG_arg_fail(1)) SWIG_fail;
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 result = (bool)(arg1)->IsOk();
6472
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 {
6477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6478 }
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6486 PyObject *resultobj;
6487 wxCaret *arg1 = (wxCaret *) 0 ;
6488 bool result;
6489 PyObject * obj0 = 0 ;
6490 char *kwnames[] = {
6491 (char *) "self", NULL
6492 };
6493
6494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6496 if (SWIG_arg_fail(1)) SWIG_fail;
6497 {
6498 PyThreadState* __tstate = wxPyBeginAllowThreads();
6499 result = (bool)(arg1)->IsVisible();
6500
6501 wxPyEndAllowThreads(__tstate);
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 {
6505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6506 }
6507 return resultobj;
6508 fail:
6509 return NULL;
6510 }
6511
6512
6513 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6514 PyObject *resultobj;
6515 wxCaret *arg1 = (wxCaret *) 0 ;
6516 wxPoint result;
6517 PyObject * obj0 = 0 ;
6518 char *kwnames[] = {
6519 (char *) "self", NULL
6520 };
6521
6522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6524 if (SWIG_arg_fail(1)) SWIG_fail;
6525 {
6526 PyThreadState* __tstate = wxPyBeginAllowThreads();
6527 result = (arg1)->GetPosition();
6528
6529 wxPyEndAllowThreads(__tstate);
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 {
6533 wxPoint * resultptr;
6534 resultptr = new wxPoint((wxPoint &)(result));
6535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6536 }
6537 return resultobj;
6538 fail:
6539 return NULL;
6540 }
6541
6542
6543 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6544 PyObject *resultobj;
6545 wxCaret *arg1 = (wxCaret *) 0 ;
6546 int *arg2 = (int *) 0 ;
6547 int *arg3 = (int *) 0 ;
6548 int temp2 ;
6549 int res2 = 0 ;
6550 int temp3 ;
6551 int res3 = 0 ;
6552 PyObject * obj0 = 0 ;
6553 char *kwnames[] = {
6554 (char *) "self", NULL
6555 };
6556
6557 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6558 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6561 if (SWIG_arg_fail(1)) SWIG_fail;
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 (arg1)->GetPosition(arg2,arg3);
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 Py_INCREF(Py_None); resultobj = Py_None;
6570 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6571 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6572 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6573 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6574 return resultobj;
6575 fail:
6576 return NULL;
6577 }
6578
6579
6580 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6581 PyObject *resultobj;
6582 wxCaret *arg1 = (wxCaret *) 0 ;
6583 wxSize result;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6591 if (SWIG_arg_fail(1)) SWIG_fail;
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 result = (arg1)->GetSize();
6595
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 {
6600 wxSize * resultptr;
6601 resultptr = new wxSize((wxSize &)(result));
6602 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6603 }
6604 return resultobj;
6605 fail:
6606 return NULL;
6607 }
6608
6609
6610 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6611 PyObject *resultobj;
6612 wxCaret *arg1 = (wxCaret *) 0 ;
6613 int *arg2 = (int *) 0 ;
6614 int *arg3 = (int *) 0 ;
6615 int temp2 ;
6616 int res2 = 0 ;
6617 int temp3 ;
6618 int res3 = 0 ;
6619 PyObject * obj0 = 0 ;
6620 char *kwnames[] = {
6621 (char *) "self", NULL
6622 };
6623
6624 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6625 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6628 if (SWIG_arg_fail(1)) SWIG_fail;
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->GetSize(arg2,arg3);
6632
6633 wxPyEndAllowThreads(__tstate);
6634 if (PyErr_Occurred()) SWIG_fail;
6635 }
6636 Py_INCREF(Py_None); resultobj = Py_None;
6637 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6638 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6639 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6640 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj;
6649 wxCaret *arg1 = (wxCaret *) 0 ;
6650 wxWindow *result;
6651 PyObject * obj0 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6658 if (SWIG_arg_fail(1)) SWIG_fail;
6659 {
6660 PyThreadState* __tstate = wxPyBeginAllowThreads();
6661 result = (wxWindow *)(arg1)->GetWindow();
6662
6663 wxPyEndAllowThreads(__tstate);
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 {
6667 resultobj = wxPyMake_wxObject(result, 0);
6668 }
6669 return resultobj;
6670 fail:
6671 return NULL;
6672 }
6673
6674
6675 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6676 PyObject *resultobj;
6677 wxCaret *arg1 = (wxCaret *) 0 ;
6678 int arg2 ;
6679 int arg3 ;
6680 PyObject * obj0 = 0 ;
6681 PyObject * obj1 = 0 ;
6682 PyObject * obj2 = 0 ;
6683 char *kwnames[] = {
6684 (char *) "self",(char *) "x",(char *) "y", NULL
6685 };
6686
6687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6689 if (SWIG_arg_fail(1)) SWIG_fail;
6690 {
6691 arg2 = (int)(SWIG_As_int(obj1));
6692 if (SWIG_arg_fail(2)) SWIG_fail;
6693 }
6694 {
6695 arg3 = (int)(SWIG_As_int(obj2));
6696 if (SWIG_arg_fail(3)) SWIG_fail;
6697 }
6698 {
6699 PyThreadState* __tstate = wxPyBeginAllowThreads();
6700 (arg1)->Move(arg2,arg3);
6701
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 Py_INCREF(Py_None); resultobj = Py_None;
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj;
6714 wxCaret *arg1 = (wxCaret *) 0 ;
6715 wxPoint *arg2 = 0 ;
6716 wxPoint temp2 ;
6717 PyObject * obj0 = 0 ;
6718 PyObject * obj1 = 0 ;
6719 char *kwnames[] = {
6720 (char *) "self",(char *) "pt", NULL
6721 };
6722
6723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6725 if (SWIG_arg_fail(1)) SWIG_fail;
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 PyThreadState* __tstate = wxPyBeginAllowThreads();
6732 (arg1)->Move((wxPoint const &)*arg2);
6733
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 Py_INCREF(Py_None); resultobj = Py_None;
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6745 PyObject *resultobj;
6746 wxCaret *arg1 = (wxCaret *) 0 ;
6747 int arg2 ;
6748 int arg3 ;
6749 PyObject * obj0 = 0 ;
6750 PyObject * obj1 = 0 ;
6751 PyObject * obj2 = 0 ;
6752 char *kwnames[] = {
6753 (char *) "self",(char *) "width",(char *) "height", NULL
6754 };
6755
6756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6758 if (SWIG_arg_fail(1)) SWIG_fail;
6759 {
6760 arg2 = (int)(SWIG_As_int(obj1));
6761 if (SWIG_arg_fail(2)) SWIG_fail;
6762 }
6763 {
6764 arg3 = (int)(SWIG_As_int(obj2));
6765 if (SWIG_arg_fail(3)) SWIG_fail;
6766 }
6767 {
6768 PyThreadState* __tstate = wxPyBeginAllowThreads();
6769 (arg1)->SetSize(arg2,arg3);
6770
6771 wxPyEndAllowThreads(__tstate);
6772 if (PyErr_Occurred()) SWIG_fail;
6773 }
6774 Py_INCREF(Py_None); resultobj = Py_None;
6775 return resultobj;
6776 fail:
6777 return NULL;
6778 }
6779
6780
6781 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6782 PyObject *resultobj;
6783 wxCaret *arg1 = (wxCaret *) 0 ;
6784 wxSize *arg2 = 0 ;
6785 wxSize temp2 ;
6786 PyObject * obj0 = 0 ;
6787 PyObject * obj1 = 0 ;
6788 char *kwnames[] = {
6789 (char *) "self",(char *) "size", NULL
6790 };
6791
6792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6794 if (SWIG_arg_fail(1)) SWIG_fail;
6795 {
6796 arg2 = &temp2;
6797 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetSize((wxSize const &)*arg2);
6802
6803 wxPyEndAllowThreads(__tstate);
6804 if (PyErr_Occurred()) SWIG_fail;
6805 }
6806 Py_INCREF(Py_None); resultobj = Py_None;
6807 return resultobj;
6808 fail:
6809 return NULL;
6810 }
6811
6812
6813 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6814 PyObject *resultobj;
6815 wxCaret *arg1 = (wxCaret *) 0 ;
6816 int arg2 = (int) true ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char *kwnames[] = {
6820 (char *) "self",(char *) "show", NULL
6821 };
6822
6823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6825 if (SWIG_arg_fail(1)) SWIG_fail;
6826 if (obj1) {
6827 {
6828 arg2 = (int)(SWIG_As_int(obj1));
6829 if (SWIG_arg_fail(2)) SWIG_fail;
6830 }
6831 }
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 (arg1)->Show(arg2);
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 Py_INCREF(Py_None); resultobj = Py_None;
6840 return resultobj;
6841 fail:
6842 return NULL;
6843 }
6844
6845
6846 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6847 PyObject *resultobj;
6848 wxCaret *arg1 = (wxCaret *) 0 ;
6849 PyObject * obj0 = 0 ;
6850 char *kwnames[] = {
6851 (char *) "self", NULL
6852 };
6853
6854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6856 if (SWIG_arg_fail(1)) SWIG_fail;
6857 {
6858 PyThreadState* __tstate = wxPyBeginAllowThreads();
6859 (arg1)->Hide();
6860
6861 wxPyEndAllowThreads(__tstate);
6862 if (PyErr_Occurred()) SWIG_fail;
6863 }
6864 Py_INCREF(Py_None); resultobj = Py_None;
6865 return resultobj;
6866 fail:
6867 return NULL;
6868 }
6869
6870
6871 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6872 PyObject *resultobj;
6873 int result;
6874 char *kwnames[] = {
6875 NULL
6876 };
6877
6878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (int)wxCaret::GetBlinkTime();
6882
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 {
6887 resultobj = SWIG_From_int((int)(result));
6888 }
6889 return resultobj;
6890 fail:
6891 return NULL;
6892 }
6893
6894
6895 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6896 PyObject *resultobj;
6897 int arg1 ;
6898 PyObject * obj0 = 0 ;
6899 char *kwnames[] = {
6900 (char *) "milliseconds", NULL
6901 };
6902
6903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6904 {
6905 arg1 = (int)(SWIG_As_int(obj0));
6906 if (SWIG_arg_fail(1)) SWIG_fail;
6907 }
6908 {
6909 PyThreadState* __tstate = wxPyBeginAllowThreads();
6910 wxCaret::SetBlinkTime(arg1);
6911
6912 wxPyEndAllowThreads(__tstate);
6913 if (PyErr_Occurred()) SWIG_fail;
6914 }
6915 Py_INCREF(Py_None); resultobj = Py_None;
6916 return resultobj;
6917 fail:
6918 return NULL;
6919 }
6920
6921
6922 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6923 PyObject *obj;
6924 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6925 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6926 Py_INCREF(obj);
6927 return Py_BuildValue((char *)"");
6928 }
6929 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj;
6931 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6932 wxBusyCursor *result;
6933 PyObject * obj0 = 0 ;
6934 char *kwnames[] = {
6935 (char *) "cursor", NULL
6936 };
6937
6938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6939 if (obj0) {
6940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6941 if (SWIG_arg_fail(1)) SWIG_fail;
6942 }
6943 {
6944 if (!wxPyCheckForApp()) SWIG_fail;
6945 PyThreadState* __tstate = wxPyBeginAllowThreads();
6946 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6947
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj;
6960 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6961 PyObject * obj0 = 0 ;
6962 char *kwnames[] = {
6963 (char *) "self", NULL
6964 };
6965
6966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6968 if (SWIG_arg_fail(1)) SWIG_fail;
6969 {
6970 PyThreadState* __tstate = wxPyBeginAllowThreads();
6971 delete arg1;
6972
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 Py_INCREF(Py_None); resultobj = Py_None;
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6984 PyObject *obj;
6985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6986 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6987 Py_INCREF(obj);
6988 return Py_BuildValue((char *)"");
6989 }
6990 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj;
6992 wxWindow *arg1 = (wxWindow *) NULL ;
6993 wxWindowDisabler *result;
6994 PyObject * obj0 = 0 ;
6995 char *kwnames[] = {
6996 (char *) "winToSkip", NULL
6997 };
6998
6999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
7000 if (obj0) {
7001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7002 if (SWIG_arg_fail(1)) SWIG_fail;
7003 }
7004 {
7005 if (!wxPyCheckForApp()) SWIG_fail;
7006 PyThreadState* __tstate = wxPyBeginAllowThreads();
7007 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
7008
7009 wxPyEndAllowThreads(__tstate);
7010 if (PyErr_Occurred()) SWIG_fail;
7011 }
7012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
7013 return resultobj;
7014 fail:
7015 return NULL;
7016 }
7017
7018
7019 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
7020 PyObject *resultobj;
7021 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
7022 PyObject * obj0 = 0 ;
7023 char *kwnames[] = {
7024 (char *) "self", NULL
7025 };
7026
7027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
7028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
7029 if (SWIG_arg_fail(1)) SWIG_fail;
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 delete arg1;
7033
7034 wxPyEndAllowThreads(__tstate);
7035 if (PyErr_Occurred()) SWIG_fail;
7036 }
7037 Py_INCREF(Py_None); resultobj = Py_None;
7038 return resultobj;
7039 fail:
7040 return NULL;
7041 }
7042
7043
7044 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
7045 PyObject *obj;
7046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7047 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7048 Py_INCREF(obj);
7049 return Py_BuildValue((char *)"");
7050 }
7051 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7052 PyObject *resultobj;
7053 wxString *arg1 = 0 ;
7054 wxBusyInfo *result;
7055 bool temp1 = false ;
7056 PyObject * obj0 = 0 ;
7057 char *kwnames[] = {
7058 (char *) "message", NULL
7059 };
7060
7061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7062 {
7063 arg1 = wxString_in_helper(obj0);
7064 if (arg1 == NULL) SWIG_fail;
7065 temp1 = true;
7066 }
7067 {
7068 if (!wxPyCheckForApp()) SWIG_fail;
7069 PyThreadState* __tstate = wxPyBeginAllowThreads();
7070 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7071
7072 wxPyEndAllowThreads(__tstate);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7076 {
7077 if (temp1)
7078 delete arg1;
7079 }
7080 return resultobj;
7081 fail:
7082 {
7083 if (temp1)
7084 delete arg1;
7085 }
7086 return NULL;
7087 }
7088
7089
7090 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7091 PyObject *resultobj;
7092 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7093 PyObject * obj0 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 {
7102 PyThreadState* __tstate = wxPyBeginAllowThreads();
7103 delete arg1;
7104
7105 wxPyEndAllowThreads(__tstate);
7106 if (PyErr_Occurred()) SWIG_fail;
7107 }
7108 Py_INCREF(Py_None); resultobj = Py_None;
7109 return resultobj;
7110 fail:
7111 return NULL;
7112 }
7113
7114
7115 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7116 PyObject *obj;
7117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7118 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7119 Py_INCREF(obj);
7120 return Py_BuildValue((char *)"");
7121 }
7122 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7123 PyObject *resultobj;
7124 wxStopWatch *result;
7125 char *kwnames[] = {
7126 NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 result = (wxStopWatch *)new wxStopWatch();
7133
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj;
7146 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7147 long arg2 = (long) 0 ;
7148 PyObject * obj0 = 0 ;
7149 PyObject * obj1 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self",(char *) "t0", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 if (obj1) {
7158 {
7159 arg2 = (long)(SWIG_As_long(obj1));
7160 if (SWIG_arg_fail(2)) SWIG_fail;
7161 }
7162 }
7163 {
7164 PyThreadState* __tstate = wxPyBeginAllowThreads();
7165 (arg1)->Start(arg2);
7166
7167 wxPyEndAllowThreads(__tstate);
7168 if (PyErr_Occurred()) SWIG_fail;
7169 }
7170 Py_INCREF(Py_None); resultobj = Py_None;
7171 return resultobj;
7172 fail:
7173 return NULL;
7174 }
7175
7176
7177 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7178 PyObject *resultobj;
7179 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7180 PyObject * obj0 = 0 ;
7181 char *kwnames[] = {
7182 (char *) "self", NULL
7183 };
7184
7185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7187 if (SWIG_arg_fail(1)) SWIG_fail;
7188 {
7189 PyThreadState* __tstate = wxPyBeginAllowThreads();
7190 (arg1)->Pause();
7191
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 Py_INCREF(Py_None); resultobj = Py_None;
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj;
7204 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7205 PyObject * obj0 = 0 ;
7206 char *kwnames[] = {
7207 (char *) "self", NULL
7208 };
7209
7210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7212 if (SWIG_arg_fail(1)) SWIG_fail;
7213 {
7214 PyThreadState* __tstate = wxPyBeginAllowThreads();
7215 (arg1)->Resume();
7216
7217 wxPyEndAllowThreads(__tstate);
7218 if (PyErr_Occurred()) SWIG_fail;
7219 }
7220 Py_INCREF(Py_None); resultobj = Py_None;
7221 return resultobj;
7222 fail:
7223 return NULL;
7224 }
7225
7226
7227 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7228 PyObject *resultobj;
7229 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7230 long result;
7231 PyObject * obj0 = 0 ;
7232 char *kwnames[] = {
7233 (char *) "self", NULL
7234 };
7235
7236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7238 if (SWIG_arg_fail(1)) SWIG_fail;
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (long)((wxStopWatch const *)arg1)->Time();
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 {
7247 resultobj = SWIG_From_long((long)(result));
7248 }
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7256 PyObject *obj;
7257 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7258 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7259 Py_INCREF(obj);
7260 return Py_BuildValue((char *)"");
7261 }
7262 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7263 PyObject *resultobj;
7264 int arg1 = (int) 9 ;
7265 int arg2 = (int) wxID_FILE1 ;
7266 wxFileHistory *result;
7267 PyObject * obj0 = 0 ;
7268 PyObject * obj1 = 0 ;
7269 char *kwnames[] = {
7270 (char *) "maxFiles",(char *) "idBase", NULL
7271 };
7272
7273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7274 if (obj0) {
7275 {
7276 arg1 = (int)(SWIG_As_int(obj0));
7277 if (SWIG_arg_fail(1)) SWIG_fail;
7278 }
7279 }
7280 if (obj1) {
7281 {
7282 arg2 = (int)(SWIG_As_int(obj1));
7283 if (SWIG_arg_fail(2)) SWIG_fail;
7284 }
7285 }
7286 {
7287 PyThreadState* __tstate = wxPyBeginAllowThreads();
7288 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7289
7290 wxPyEndAllowThreads(__tstate);
7291 if (PyErr_Occurred()) SWIG_fail;
7292 }
7293 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7294 return resultobj;
7295 fail:
7296 return NULL;
7297 }
7298
7299
7300 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj;
7302 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7303 PyObject * obj0 = 0 ;
7304 char *kwnames[] = {
7305 (char *) "self", NULL
7306 };
7307
7308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7310 if (SWIG_arg_fail(1)) SWIG_fail;
7311 {
7312 PyThreadState* __tstate = wxPyBeginAllowThreads();
7313 delete arg1;
7314
7315 wxPyEndAllowThreads(__tstate);
7316 if (PyErr_Occurred()) SWIG_fail;
7317 }
7318 Py_INCREF(Py_None); resultobj = Py_None;
7319 return resultobj;
7320 fail:
7321 return NULL;
7322 }
7323
7324
7325 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj;
7327 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7328 wxString *arg2 = 0 ;
7329 bool temp2 = false ;
7330 PyObject * obj0 = 0 ;
7331 PyObject * obj1 = 0 ;
7332 char *kwnames[] = {
7333 (char *) "self",(char *) "file", NULL
7334 };
7335
7336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7338 if (SWIG_arg_fail(1)) SWIG_fail;
7339 {
7340 arg2 = wxString_in_helper(obj1);
7341 if (arg2 == NULL) SWIG_fail;
7342 temp2 = true;
7343 }
7344 {
7345 PyThreadState* __tstate = wxPyBeginAllowThreads();
7346 (arg1)->AddFileToHistory((wxString const &)*arg2);
7347
7348 wxPyEndAllowThreads(__tstate);
7349 if (PyErr_Occurred()) SWIG_fail;
7350 }
7351 Py_INCREF(Py_None); resultobj = Py_None;
7352 {
7353 if (temp2)
7354 delete arg2;
7355 }
7356 return resultobj;
7357 fail:
7358 {
7359 if (temp2)
7360 delete arg2;
7361 }
7362 return NULL;
7363 }
7364
7365
7366 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7367 PyObject *resultobj;
7368 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7369 int arg2 ;
7370 PyObject * obj0 = 0 ;
7371 PyObject * obj1 = 0 ;
7372 char *kwnames[] = {
7373 (char *) "self",(char *) "i", NULL
7374 };
7375
7376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",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 = (int)(SWIG_As_int(obj1));
7381 if (SWIG_arg_fail(2)) SWIG_fail;
7382 }
7383 {
7384 PyThreadState* __tstate = wxPyBeginAllowThreads();
7385 (arg1)->RemoveFileFromHistory(arg2);
7386
7387 wxPyEndAllowThreads(__tstate);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 Py_INCREF(Py_None); resultobj = Py_None;
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj;
7399 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7400 int result;
7401 PyObject * obj0 = 0 ;
7402 char *kwnames[] = {
7403 (char *) "self", NULL
7404 };
7405
7406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7408 if (SWIG_arg_fail(1)) SWIG_fail;
7409 {
7410 PyThreadState* __tstate = wxPyBeginAllowThreads();
7411 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7412
7413 wxPyEndAllowThreads(__tstate);
7414 if (PyErr_Occurred()) SWIG_fail;
7415 }
7416 {
7417 resultobj = SWIG_From_int((int)(result));
7418 }
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj;
7427 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7428 wxMenu *arg2 = (wxMenu *) 0 ;
7429 PyObject * obj0 = 0 ;
7430 PyObject * obj1 = 0 ;
7431 char *kwnames[] = {
7432 (char *) "self",(char *) "menu", NULL
7433 };
7434
7435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7437 if (SWIG_arg_fail(1)) SWIG_fail;
7438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(2)) SWIG_fail;
7440 {
7441 PyThreadState* __tstate = wxPyBeginAllowThreads();
7442 (arg1)->UseMenu(arg2);
7443
7444 wxPyEndAllowThreads(__tstate);
7445 if (PyErr_Occurred()) SWIG_fail;
7446 }
7447 Py_INCREF(Py_None); resultobj = Py_None;
7448 return resultobj;
7449 fail:
7450 return NULL;
7451 }
7452
7453
7454 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7455 PyObject *resultobj;
7456 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7457 wxMenu *arg2 = (wxMenu *) 0 ;
7458 PyObject * obj0 = 0 ;
7459 PyObject * obj1 = 0 ;
7460 char *kwnames[] = {
7461 (char *) "self",(char *) "menu", NULL
7462 };
7463
7464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(1)) SWIG_fail;
7467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7468 if (SWIG_arg_fail(2)) SWIG_fail;
7469 {
7470 PyThreadState* __tstate = wxPyBeginAllowThreads();
7471 (arg1)->RemoveMenu(arg2);
7472
7473 wxPyEndAllowThreads(__tstate);
7474 if (PyErr_Occurred()) SWIG_fail;
7475 }
7476 Py_INCREF(Py_None); resultobj = Py_None;
7477 return resultobj;
7478 fail:
7479 return NULL;
7480 }
7481
7482
7483 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7484 PyObject *resultobj;
7485 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7486 wxConfigBase *arg2 = 0 ;
7487 PyObject * obj0 = 0 ;
7488 PyObject * obj1 = 0 ;
7489 char *kwnames[] = {
7490 (char *) "self",(char *) "config", NULL
7491 };
7492
7493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7495 if (SWIG_arg_fail(1)) SWIG_fail;
7496 {
7497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7498 if (SWIG_arg_fail(2)) SWIG_fail;
7499 if (arg2 == NULL) {
7500 SWIG_null_ref("wxConfigBase");
7501 }
7502 if (SWIG_arg_fail(2)) SWIG_fail;
7503 }
7504 {
7505 PyThreadState* __tstate = wxPyBeginAllowThreads();
7506 (arg1)->Load(*arg2);
7507
7508 wxPyEndAllowThreads(__tstate);
7509 if (PyErr_Occurred()) SWIG_fail;
7510 }
7511 Py_INCREF(Py_None); resultobj = Py_None;
7512 return resultobj;
7513 fail:
7514 return NULL;
7515 }
7516
7517
7518 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7519 PyObject *resultobj;
7520 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7521 wxConfigBase *arg2 = 0 ;
7522 PyObject * obj0 = 0 ;
7523 PyObject * obj1 = 0 ;
7524 char *kwnames[] = {
7525 (char *) "self",(char *) "config", NULL
7526 };
7527
7528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7530 if (SWIG_arg_fail(1)) SWIG_fail;
7531 {
7532 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7533 if (SWIG_arg_fail(2)) SWIG_fail;
7534 if (arg2 == NULL) {
7535 SWIG_null_ref("wxConfigBase");
7536 }
7537 if (SWIG_arg_fail(2)) SWIG_fail;
7538 }
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 (arg1)->Save(*arg2);
7542
7543 wxPyEndAllowThreads(__tstate);
7544 if (PyErr_Occurred()) SWIG_fail;
7545 }
7546 Py_INCREF(Py_None); resultobj = Py_None;
7547 return resultobj;
7548 fail:
7549 return NULL;
7550 }
7551
7552
7553 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7554 PyObject *resultobj;
7555 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7556 PyObject * obj0 = 0 ;
7557 char *kwnames[] = {
7558 (char *) "self", NULL
7559 };
7560
7561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7563 if (SWIG_arg_fail(1)) SWIG_fail;
7564 {
7565 PyThreadState* __tstate = wxPyBeginAllowThreads();
7566 (arg1)->AddFilesToMenu();
7567
7568 wxPyEndAllowThreads(__tstate);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 Py_INCREF(Py_None); resultobj = Py_None;
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7581 wxMenu *arg2 = (wxMenu *) 0 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self",(char *) "menu", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7592 if (SWIG_arg_fail(2)) SWIG_fail;
7593 {
7594 PyThreadState* __tstate = wxPyBeginAllowThreads();
7595 (arg1)->AddFilesToMenu(arg2);
7596
7597 wxPyEndAllowThreads(__tstate);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 Py_INCREF(Py_None); resultobj = Py_None;
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj;
7609 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7610 int arg2 ;
7611 wxString result;
7612 PyObject * obj0 = 0 ;
7613 PyObject * obj1 = 0 ;
7614 char *kwnames[] = {
7615 (char *) "self",(char *) "i", NULL
7616 };
7617
7618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7620 if (SWIG_arg_fail(1)) SWIG_fail;
7621 {
7622 arg2 = (int)(SWIG_As_int(obj1));
7623 if (SWIG_arg_fail(2)) SWIG_fail;
7624 }
7625 {
7626 PyThreadState* __tstate = wxPyBeginAllowThreads();
7627 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7628
7629 wxPyEndAllowThreads(__tstate);
7630 if (PyErr_Occurred()) SWIG_fail;
7631 }
7632 {
7633 #if wxUSE_UNICODE
7634 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7635 #else
7636 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7637 #endif
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj;
7647 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7648 int result;
7649 PyObject * obj0 = 0 ;
7650 char *kwnames[] = {
7651 (char *) "self", NULL
7652 };
7653
7654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7656 if (SWIG_arg_fail(1)) SWIG_fail;
7657 {
7658 PyThreadState* __tstate = wxPyBeginAllowThreads();
7659 result = (int)((wxFileHistory const *)arg1)->GetCount();
7660
7661 wxPyEndAllowThreads(__tstate);
7662 if (PyErr_Occurred()) SWIG_fail;
7663 }
7664 {
7665 resultobj = SWIG_From_int((int)(result));
7666 }
7667 return resultobj;
7668 fail:
7669 return NULL;
7670 }
7671
7672
7673 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7674 PyObject *obj;
7675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7676 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7677 Py_INCREF(obj);
7678 return Py_BuildValue((char *)"");
7679 }
7680 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj;
7682 wxString *arg1 = 0 ;
7683 wxString const &arg2_defvalue = wxPyEmptyString ;
7684 wxString *arg2 = (wxString *) &arg2_defvalue ;
7685 wxSingleInstanceChecker *result;
7686 bool temp1 = false ;
7687 bool temp2 = false ;
7688 PyObject * obj0 = 0 ;
7689 PyObject * obj1 = 0 ;
7690 char *kwnames[] = {
7691 (char *) "name",(char *) "path", NULL
7692 };
7693
7694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7695 {
7696 arg1 = wxString_in_helper(obj0);
7697 if (arg1 == NULL) SWIG_fail;
7698 temp1 = true;
7699 }
7700 if (obj1) {
7701 {
7702 arg2 = wxString_in_helper(obj1);
7703 if (arg2 == NULL) SWIG_fail;
7704 temp2 = true;
7705 }
7706 }
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7715 {
7716 if (temp1)
7717 delete arg1;
7718 }
7719 {
7720 if (temp2)
7721 delete arg2;
7722 }
7723 return resultobj;
7724 fail:
7725 {
7726 if (temp1)
7727 delete arg1;
7728 }
7729 {
7730 if (temp2)
7731 delete arg2;
7732 }
7733 return NULL;
7734 }
7735
7736
7737 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj;
7739 wxSingleInstanceChecker *result;
7740 char *kwnames[] = {
7741 NULL
7742 };
7743
7744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7745 {
7746 PyThreadState* __tstate = wxPyBeginAllowThreads();
7747 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7748
7749 wxPyEndAllowThreads(__tstate);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7753 return resultobj;
7754 fail:
7755 return NULL;
7756 }
7757
7758
7759 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7760 PyObject *resultobj;
7761 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7762 PyObject * obj0 = 0 ;
7763 char *kwnames[] = {
7764 (char *) "self", NULL
7765 };
7766
7767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7769 if (SWIG_arg_fail(1)) SWIG_fail;
7770 {
7771 PyThreadState* __tstate = wxPyBeginAllowThreads();
7772 delete arg1;
7773
7774 wxPyEndAllowThreads(__tstate);
7775 if (PyErr_Occurred()) SWIG_fail;
7776 }
7777 Py_INCREF(Py_None); resultobj = Py_None;
7778 return resultobj;
7779 fail:
7780 return NULL;
7781 }
7782
7783
7784 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7785 PyObject *resultobj;
7786 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7787 wxString *arg2 = 0 ;
7788 wxString const &arg3_defvalue = wxPyEmptyString ;
7789 wxString *arg3 = (wxString *) &arg3_defvalue ;
7790 bool result;
7791 bool temp2 = false ;
7792 bool temp3 = false ;
7793 PyObject * obj0 = 0 ;
7794 PyObject * obj1 = 0 ;
7795 PyObject * obj2 = 0 ;
7796 char *kwnames[] = {
7797 (char *) "self",(char *) "name",(char *) "path", NULL
7798 };
7799
7800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7802 if (SWIG_arg_fail(1)) SWIG_fail;
7803 {
7804 arg2 = wxString_in_helper(obj1);
7805 if (arg2 == NULL) SWIG_fail;
7806 temp2 = true;
7807 }
7808 if (obj2) {
7809 {
7810 arg3 = wxString_in_helper(obj2);
7811 if (arg3 == NULL) SWIG_fail;
7812 temp3 = true;
7813 }
7814 }
7815 {
7816 PyThreadState* __tstate = wxPyBeginAllowThreads();
7817 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7818
7819 wxPyEndAllowThreads(__tstate);
7820 if (PyErr_Occurred()) SWIG_fail;
7821 }
7822 {
7823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7824 }
7825 {
7826 if (temp2)
7827 delete arg2;
7828 }
7829 {
7830 if (temp3)
7831 delete arg3;
7832 }
7833 return resultobj;
7834 fail:
7835 {
7836 if (temp2)
7837 delete arg2;
7838 }
7839 {
7840 if (temp3)
7841 delete arg3;
7842 }
7843 return NULL;
7844 }
7845
7846
7847 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7848 PyObject *resultobj;
7849 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7850 bool result;
7851 PyObject * obj0 = 0 ;
7852 char *kwnames[] = {
7853 (char *) "self", NULL
7854 };
7855
7856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7858 if (SWIG_arg_fail(1)) SWIG_fail;
7859 {
7860 PyThreadState* __tstate = wxPyBeginAllowThreads();
7861 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7862
7863 wxPyEndAllowThreads(__tstate);
7864 if (PyErr_Occurred()) SWIG_fail;
7865 }
7866 {
7867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7868 }
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7876 PyObject *obj;
7877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7878 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7879 Py_INCREF(obj);
7880 return Py_BuildValue((char *)"");
7881 }
7882 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxWindow *arg1 = (wxWindow *) 0 ;
7885 wxDC *arg2 = 0 ;
7886 bool result;
7887 PyObject * obj0 = 0 ;
7888 PyObject * obj1 = 0 ;
7889 char *kwnames[] = {
7890 (char *) "window",(char *) "dc", NULL
7891 };
7892
7893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(1)) SWIG_fail;
7896 {
7897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7898 if (SWIG_arg_fail(2)) SWIG_fail;
7899 if (arg2 == NULL) {
7900 SWIG_null_ref("wxDC");
7901 }
7902 if (SWIG_arg_fail(2)) SWIG_fail;
7903 }
7904 {
7905 PyThreadState* __tstate = wxPyBeginAllowThreads();
7906 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7907
7908 wxPyEndAllowThreads(__tstate);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 {
7912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7913 }
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj;
7922 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7923 PyObject * obj0 = 0 ;
7924 char *kwnames[] = {
7925 (char *) "self", NULL
7926 };
7927
7928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7930 if (SWIG_arg_fail(1)) SWIG_fail;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 delete arg1;
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 Py_INCREF(Py_None); resultobj = Py_None;
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7946 PyObject *resultobj;
7947 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7948 wxString result;
7949 PyObject * obj0 = 0 ;
7950 char *kwnames[] = {
7951 (char *) "self", NULL
7952 };
7953
7954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7956 if (SWIG_arg_fail(1)) SWIG_fail;
7957 {
7958 PyThreadState* __tstate = wxPyBeginAllowThreads();
7959 result = (arg1)->GetTip();
7960
7961 wxPyEndAllowThreads(__tstate);
7962 if (PyErr_Occurred()) SWIG_fail;
7963 }
7964 {
7965 #if wxUSE_UNICODE
7966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7967 #else
7968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7969 #endif
7970 }
7971 return resultobj;
7972 fail:
7973 return NULL;
7974 }
7975
7976
7977 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7978 PyObject *resultobj;
7979 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7980 size_t result;
7981 PyObject * obj0 = 0 ;
7982 char *kwnames[] = {
7983 (char *) "self", NULL
7984 };
7985
7986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7988 if (SWIG_arg_fail(1)) SWIG_fail;
7989 {
7990 PyThreadState* __tstate = wxPyBeginAllowThreads();
7991 result = (size_t)(arg1)->GetCurrentTip();
7992
7993 wxPyEndAllowThreads(__tstate);
7994 if (PyErr_Occurred()) SWIG_fail;
7995 }
7996 {
7997 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7998 }
7999 return resultobj;
8000 fail:
8001 return NULL;
8002 }
8003
8004
8005 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
8006 PyObject *resultobj;
8007 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
8008 wxString *arg2 = 0 ;
8009 wxString result;
8010 bool temp2 = false ;
8011 PyObject * obj0 = 0 ;
8012 PyObject * obj1 = 0 ;
8013 char *kwnames[] = {
8014 (char *) "self",(char *) "tip", NULL
8015 };
8016
8017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
8018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8019 if (SWIG_arg_fail(1)) SWIG_fail;
8020 {
8021 arg2 = wxString_in_helper(obj1);
8022 if (arg2 == NULL) SWIG_fail;
8023 temp2 = true;
8024 }
8025 {
8026 PyThreadState* __tstate = wxPyBeginAllowThreads();
8027 result = (arg1)->PreprocessTip((wxString const &)*arg2);
8028
8029 wxPyEndAllowThreads(__tstate);
8030 if (PyErr_Occurred()) SWIG_fail;
8031 }
8032 {
8033 #if wxUSE_UNICODE
8034 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8035 #else
8036 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8037 #endif
8038 }
8039 {
8040 if (temp2)
8041 delete arg2;
8042 }
8043 return resultobj;
8044 fail:
8045 {
8046 if (temp2)
8047 delete arg2;
8048 }
8049 return NULL;
8050 }
8051
8052
8053 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8054 PyObject *obj;
8055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8056 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8057 Py_INCREF(obj);
8058 return Py_BuildValue((char *)"");
8059 }
8060 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 size_t arg1 ;
8063 wxPyTipProvider *result;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "currentTip", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8070 {
8071 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8072 if (SWIG_arg_fail(1)) SWIG_fail;
8073 }
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8089 PyObject *resultobj;
8090 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8091 PyObject *arg2 = (PyObject *) 0 ;
8092 PyObject *arg3 = (PyObject *) 0 ;
8093 PyObject * obj0 = 0 ;
8094 PyObject * obj1 = 0 ;
8095 PyObject * obj2 = 0 ;
8096 char *kwnames[] = {
8097 (char *) "self",(char *) "self",(char *) "_class", NULL
8098 };
8099
8100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8102 if (SWIG_arg_fail(1)) SWIG_fail;
8103 arg2 = obj1;
8104 arg3 = obj2;
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 (arg1)->_setCallbackInfo(arg2,arg3);
8108
8109 wxPyEndAllowThreads(__tstate);
8110 if (PyErr_Occurred()) SWIG_fail;
8111 }
8112 Py_INCREF(Py_None); resultobj = Py_None;
8113 return resultobj;
8114 fail:
8115 return NULL;
8116 }
8117
8118
8119 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8120 PyObject *obj;
8121 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8122 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8123 Py_INCREF(obj);
8124 return Py_BuildValue((char *)"");
8125 }
8126 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8127 PyObject *resultobj;
8128 wxWindow *arg1 = (wxWindow *) 0 ;
8129 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8130 bool arg3 = (bool) true ;
8131 bool result;
8132 PyObject * obj0 = 0 ;
8133 PyObject * obj1 = 0 ;
8134 PyObject * obj2 = 0 ;
8135 char *kwnames[] = {
8136 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8137 };
8138
8139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8141 if (SWIG_arg_fail(1)) SWIG_fail;
8142 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8143 if (SWIG_arg_fail(2)) SWIG_fail;
8144 if (obj2) {
8145 {
8146 arg3 = (bool)(SWIG_As_bool(obj2));
8147 if (SWIG_arg_fail(3)) SWIG_fail;
8148 }
8149 }
8150 {
8151 if (!wxPyCheckForApp()) SWIG_fail;
8152 PyThreadState* __tstate = wxPyBeginAllowThreads();
8153 result = (bool)wxShowTip(arg1,arg2,arg3);
8154
8155 wxPyEndAllowThreads(__tstate);
8156 if (PyErr_Occurred()) SWIG_fail;
8157 }
8158 {
8159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8160 }
8161 return resultobj;
8162 fail:
8163 return NULL;
8164 }
8165
8166
8167 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj;
8169 wxString *arg1 = 0 ;
8170 size_t arg2 ;
8171 wxTipProvider *result;
8172 bool temp1 = false ;
8173 PyObject * obj0 = 0 ;
8174 PyObject * obj1 = 0 ;
8175 char *kwnames[] = {
8176 (char *) "filename",(char *) "currentTip", NULL
8177 };
8178
8179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8180 {
8181 arg1 = wxString_in_helper(obj0);
8182 if (arg1 == NULL) SWIG_fail;
8183 temp1 = true;
8184 }
8185 {
8186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8187 if (SWIG_arg_fail(2)) SWIG_fail;
8188 }
8189 {
8190 if (!wxPyCheckForApp()) SWIG_fail;
8191 PyThreadState* __tstate = wxPyBeginAllowThreads();
8192 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8193
8194 wxPyEndAllowThreads(__tstate);
8195 if (PyErr_Occurred()) SWIG_fail;
8196 }
8197 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8198 {
8199 if (temp1)
8200 delete arg1;
8201 }
8202 return resultobj;
8203 fail:
8204 {
8205 if (temp1)
8206 delete arg1;
8207 }
8208 return NULL;
8209 }
8210
8211
8212 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8213 PyObject *resultobj;
8214 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8215 int arg2 = (int) -1 ;
8216 wxPyTimer *result;
8217 PyObject * obj0 = 0 ;
8218 PyObject * obj1 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "owner",(char *) "id", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8224 if (obj0) {
8225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8226 if (SWIG_arg_fail(1)) SWIG_fail;
8227 }
8228 if (obj1) {
8229 {
8230 arg2 = (int)(SWIG_As_int(obj1));
8231 if (SWIG_arg_fail(2)) SWIG_fail;
8232 }
8233 }
8234 {
8235 if (!wxPyCheckForApp()) SWIG_fail;
8236 PyThreadState* __tstate = wxPyBeginAllowThreads();
8237 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8238
8239 wxPyEndAllowThreads(__tstate);
8240 if (PyErr_Occurred()) SWIG_fail;
8241 }
8242 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8243 return resultobj;
8244 fail:
8245 return NULL;
8246 }
8247
8248
8249 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8250 PyObject *resultobj;
8251 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8252 PyObject * obj0 = 0 ;
8253 char *kwnames[] = {
8254 (char *) "self", NULL
8255 };
8256
8257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8259 if (SWIG_arg_fail(1)) SWIG_fail;
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 delete arg1;
8263
8264 wxPyEndAllowThreads(__tstate);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 Py_INCREF(Py_None); resultobj = Py_None;
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj;
8276 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8277 PyObject *arg2 = (PyObject *) 0 ;
8278 PyObject *arg3 = (PyObject *) 0 ;
8279 int arg4 = (int) 1 ;
8280 PyObject * obj0 = 0 ;
8281 PyObject * obj1 = 0 ;
8282 PyObject * obj2 = 0 ;
8283 PyObject * obj3 = 0 ;
8284 char *kwnames[] = {
8285 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8286 };
8287
8288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8290 if (SWIG_arg_fail(1)) SWIG_fail;
8291 arg2 = obj1;
8292 arg3 = obj2;
8293 if (obj3) {
8294 {
8295 arg4 = (int)(SWIG_As_int(obj3));
8296 if (SWIG_arg_fail(4)) SWIG_fail;
8297 }
8298 }
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8302
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 Py_INCREF(Py_None); resultobj = Py_None;
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj;
8315 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8316 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8317 int arg3 = (int) -1 ;
8318 PyObject * obj0 = 0 ;
8319 PyObject * obj1 = 0 ;
8320 PyObject * obj2 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self",(char *) "owner",(char *) "id", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8329 if (SWIG_arg_fail(2)) SWIG_fail;
8330 if (obj2) {
8331 {
8332 arg3 = (int)(SWIG_As_int(obj2));
8333 if (SWIG_arg_fail(3)) SWIG_fail;
8334 }
8335 }
8336 {
8337 PyThreadState* __tstate = wxPyBeginAllowThreads();
8338 (arg1)->SetOwner(arg2,arg3);
8339
8340 wxPyEndAllowThreads(__tstate);
8341 if (PyErr_Occurred()) SWIG_fail;
8342 }
8343 Py_INCREF(Py_None); resultobj = Py_None;
8344 return resultobj;
8345 fail:
8346 return NULL;
8347 }
8348
8349
8350 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8351 PyObject *resultobj;
8352 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8353 wxEvtHandler *result;
8354 PyObject * obj0 = 0 ;
8355 char *kwnames[] = {
8356 (char *) "self", NULL
8357 };
8358
8359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8361 if (SWIG_arg_fail(1)) SWIG_fail;
8362 {
8363 PyThreadState* __tstate = wxPyBeginAllowThreads();
8364 result = (wxEvtHandler *)(arg1)->GetOwner();
8365
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 {
8370 resultobj = wxPyMake_wxObject(result, 0);
8371 }
8372 return resultobj;
8373 fail:
8374 return NULL;
8375 }
8376
8377
8378 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8379 PyObject *resultobj;
8380 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8381 int arg2 = (int) -1 ;
8382 bool arg3 = (bool) false ;
8383 bool result;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 PyObject * obj2 = 0 ;
8387 char *kwnames[] = {
8388 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8389 };
8390
8391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8393 if (SWIG_arg_fail(1)) SWIG_fail;
8394 if (obj1) {
8395 {
8396 arg2 = (int)(SWIG_As_int(obj1));
8397 if (SWIG_arg_fail(2)) SWIG_fail;
8398 }
8399 }
8400 if (obj2) {
8401 {
8402 arg3 = (bool)(SWIG_As_bool(obj2));
8403 if (SWIG_arg_fail(3)) SWIG_fail;
8404 }
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (bool)(arg1)->Start(arg2,arg3);
8409
8410 wxPyEndAllowThreads(__tstate);
8411 if (PyErr_Occurred()) SWIG_fail;
8412 }
8413 {
8414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8415 }
8416 return resultobj;
8417 fail:
8418 return NULL;
8419 }
8420
8421
8422 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8423 PyObject *resultobj;
8424 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8425 PyObject * obj0 = 0 ;
8426 char *kwnames[] = {
8427 (char *) "self", NULL
8428 };
8429
8430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8432 if (SWIG_arg_fail(1)) SWIG_fail;
8433 {
8434 PyThreadState* __tstate = wxPyBeginAllowThreads();
8435 (arg1)->Stop();
8436
8437 wxPyEndAllowThreads(__tstate);
8438 if (PyErr_Occurred()) SWIG_fail;
8439 }
8440 Py_INCREF(Py_None); resultobj = Py_None;
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8450 bool result;
8451 PyObject * obj0 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8468 }
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8478 int result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 resultobj = SWIG_From_int((int)(result));
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8504 PyObject *resultobj;
8505 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8506 bool result;
8507 PyObject * obj0 = 0 ;
8508 char *kwnames[] = {
8509 (char *) "self", NULL
8510 };
8511
8512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8514 if (SWIG_arg_fail(1)) SWIG_fail;
8515 {
8516 PyThreadState* __tstate = wxPyBeginAllowThreads();
8517 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8518
8519 wxPyEndAllowThreads(__tstate);
8520 if (PyErr_Occurred()) SWIG_fail;
8521 }
8522 {
8523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8524 }
8525 return resultobj;
8526 fail:
8527 return NULL;
8528 }
8529
8530
8531 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8532 PyObject *resultobj;
8533 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8534 int result;
8535 PyObject * obj0 = 0 ;
8536 char *kwnames[] = {
8537 (char *) "self", NULL
8538 };
8539
8540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8542 if (SWIG_arg_fail(1)) SWIG_fail;
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 result = (int)((wxPyTimer const *)arg1)->GetId();
8546
8547 wxPyEndAllowThreads(__tstate);
8548 if (PyErr_Occurred()) SWIG_fail;
8549 }
8550 {
8551 resultobj = SWIG_From_int((int)(result));
8552 }
8553 return resultobj;
8554 fail:
8555 return NULL;
8556 }
8557
8558
8559 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8560 PyObject *obj;
8561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8562 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8563 Py_INCREF(obj);
8564 return Py_BuildValue((char *)"");
8565 }
8566 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8567 PyObject *resultobj;
8568 int arg1 = (int) 0 ;
8569 int arg2 = (int) 0 ;
8570 wxTimerEvent *result;
8571 PyObject * obj0 = 0 ;
8572 PyObject * obj1 = 0 ;
8573 char *kwnames[] = {
8574 (char *) "timerid",(char *) "interval", NULL
8575 };
8576
8577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8578 if (obj0) {
8579 {
8580 arg1 = (int)(SWIG_As_int(obj0));
8581 if (SWIG_arg_fail(1)) SWIG_fail;
8582 }
8583 }
8584 if (obj1) {
8585 {
8586 arg2 = (int)(SWIG_As_int(obj1));
8587 if (SWIG_arg_fail(2)) SWIG_fail;
8588 }
8589 }
8590 {
8591 PyThreadState* __tstate = wxPyBeginAllowThreads();
8592 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8593
8594 wxPyEndAllowThreads(__tstate);
8595 if (PyErr_Occurred()) SWIG_fail;
8596 }
8597 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8598 return resultobj;
8599 fail:
8600 return NULL;
8601 }
8602
8603
8604 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj;
8606 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8607 int result;
8608 PyObject * obj0 = 0 ;
8609 char *kwnames[] = {
8610 (char *) "self", NULL
8611 };
8612
8613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8615 if (SWIG_arg_fail(1)) SWIG_fail;
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8619
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 {
8624 resultobj = SWIG_From_int((int)(result));
8625 }
8626 return resultobj;
8627 fail:
8628 return NULL;
8629 }
8630
8631
8632 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8633 PyObject *obj;
8634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8635 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8636 Py_INCREF(obj);
8637 return Py_BuildValue((char *)"");
8638 }
8639 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8640 PyObject *resultobj;
8641 wxTimer *arg1 = 0 ;
8642 wxTimerRunner *result;
8643 PyObject * obj0 = 0 ;
8644
8645 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8646 {
8647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8648 if (SWIG_arg_fail(1)) SWIG_fail;
8649 if (arg1 == NULL) {
8650 SWIG_null_ref("wxTimer");
8651 }
8652 if (SWIG_arg_fail(1)) SWIG_fail;
8653 }
8654 {
8655 if (!wxPyCheckForApp()) SWIG_fail;
8656 PyThreadState* __tstate = wxPyBeginAllowThreads();
8657 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8658
8659 wxPyEndAllowThreads(__tstate);
8660 if (PyErr_Occurred()) SWIG_fail;
8661 }
8662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8663 return resultobj;
8664 fail:
8665 return NULL;
8666 }
8667
8668
8669 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8670 PyObject *resultobj;
8671 wxTimer *arg1 = 0 ;
8672 int arg2 ;
8673 bool arg3 = (bool) false ;
8674 wxTimerRunner *result;
8675 PyObject * obj0 = 0 ;
8676 PyObject * obj1 = 0 ;
8677 PyObject * obj2 = 0 ;
8678
8679 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8680 {
8681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8682 if (SWIG_arg_fail(1)) SWIG_fail;
8683 if (arg1 == NULL) {
8684 SWIG_null_ref("wxTimer");
8685 }
8686 if (SWIG_arg_fail(1)) SWIG_fail;
8687 }
8688 {
8689 arg2 = (int)(SWIG_As_int(obj1));
8690 if (SWIG_arg_fail(2)) SWIG_fail;
8691 }
8692 if (obj2) {
8693 {
8694 arg3 = (bool)(SWIG_As_bool(obj2));
8695 if (SWIG_arg_fail(3)) SWIG_fail;
8696 }
8697 }
8698 {
8699 if (!wxPyCheckForApp()) SWIG_fail;
8700 PyThreadState* __tstate = wxPyBeginAllowThreads();
8701 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8702
8703 wxPyEndAllowThreads(__tstate);
8704 if (PyErr_Occurred()) SWIG_fail;
8705 }
8706 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8714 int argc;
8715 PyObject *argv[4];
8716 int ii;
8717
8718 argc = PyObject_Length(args);
8719 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8720 argv[ii] = PyTuple_GetItem(args,ii);
8721 }
8722 if (argc == 1) {
8723 int _v;
8724 {
8725 void *ptr = 0;
8726 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8727 _v = 0;
8728 PyErr_Clear();
8729 } else {
8730 _v = (ptr != 0);
8731 }
8732 }
8733 if (_v) {
8734 return _wrap_new_TimerRunner__SWIG_0(self,args);
8735 }
8736 }
8737 if ((argc >= 2) && (argc <= 3)) {
8738 int _v;
8739 {
8740 void *ptr = 0;
8741 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8742 _v = 0;
8743 PyErr_Clear();
8744 } else {
8745 _v = (ptr != 0);
8746 }
8747 }
8748 if (_v) {
8749 _v = SWIG_Check_int(argv[1]);
8750 if (_v) {
8751 if (argc <= 2) {
8752 return _wrap_new_TimerRunner__SWIG_1(self,args);
8753 }
8754 _v = SWIG_Check_bool(argv[2]);
8755 if (_v) {
8756 return _wrap_new_TimerRunner__SWIG_1(self,args);
8757 }
8758 }
8759 }
8760 }
8761
8762 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8763 return NULL;
8764 }
8765
8766
8767 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8768 PyObject *resultobj;
8769 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8770 PyObject * obj0 = 0 ;
8771 char *kwnames[] = {
8772 (char *) "self", NULL
8773 };
8774
8775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8777 if (SWIG_arg_fail(1)) SWIG_fail;
8778 {
8779 PyThreadState* __tstate = wxPyBeginAllowThreads();
8780 delete arg1;
8781
8782 wxPyEndAllowThreads(__tstate);
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 Py_INCREF(Py_None); resultobj = Py_None;
8786 return resultobj;
8787 fail:
8788 return NULL;
8789 }
8790
8791
8792 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8793 PyObject *resultobj;
8794 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8795 int arg2 ;
8796 bool arg3 = (bool) false ;
8797 PyObject * obj0 = 0 ;
8798 PyObject * obj1 = 0 ;
8799 PyObject * obj2 = 0 ;
8800 char *kwnames[] = {
8801 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8802 };
8803
8804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8806 if (SWIG_arg_fail(1)) SWIG_fail;
8807 {
8808 arg2 = (int)(SWIG_As_int(obj1));
8809 if (SWIG_arg_fail(2)) SWIG_fail;
8810 }
8811 if (obj2) {
8812 {
8813 arg3 = (bool)(SWIG_As_bool(obj2));
8814 if (SWIG_arg_fail(3)) SWIG_fail;
8815 }
8816 }
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 (arg1)->Start(arg2,arg3);
8820
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 Py_INCREF(Py_None); resultobj = Py_None;
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8832 PyObject *obj;
8833 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8834 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8835 Py_INCREF(obj);
8836 return Py_BuildValue((char *)"");
8837 }
8838 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8839 PyObject *resultobj;
8840 wxLog *result;
8841 char *kwnames[] = {
8842 NULL
8843 };
8844
8845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8846 {
8847 PyThreadState* __tstate = wxPyBeginAllowThreads();
8848 result = (wxLog *)new wxLog();
8849
8850 wxPyEndAllowThreads(__tstate);
8851 if (PyErr_Occurred()) SWIG_fail;
8852 }
8853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 bool result;
8863 char *kwnames[] = {
8864 NULL
8865 };
8866
8867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8868 {
8869 PyThreadState* __tstate = wxPyBeginAllowThreads();
8870 result = (bool)wxLog::IsEnabled();
8871
8872 wxPyEndAllowThreads(__tstate);
8873 if (PyErr_Occurred()) SWIG_fail;
8874 }
8875 {
8876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8877 }
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8885 PyObject *resultobj;
8886 bool arg1 = (bool) true ;
8887 bool result;
8888 PyObject * obj0 = 0 ;
8889 char *kwnames[] = {
8890 (char *) "doIt", NULL
8891 };
8892
8893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8894 if (obj0) {
8895 {
8896 arg1 = (bool)(SWIG_As_bool(obj0));
8897 if (SWIG_arg_fail(1)) SWIG_fail;
8898 }
8899 }
8900 {
8901 PyThreadState* __tstate = wxPyBeginAllowThreads();
8902 result = (bool)wxLog::EnableLogging(arg1);
8903
8904 wxPyEndAllowThreads(__tstate);
8905 if (PyErr_Occurred()) SWIG_fail;
8906 }
8907 {
8908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8909 }
8910 return resultobj;
8911 fail:
8912 return NULL;
8913 }
8914
8915
8916 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8917 PyObject *resultobj;
8918 wxLogLevel arg1 ;
8919 wxChar *arg2 = (wxChar *) 0 ;
8920 time_t arg3 ;
8921 PyObject * obj0 = 0 ;
8922 PyObject * obj1 = 0 ;
8923 PyObject * obj2 = 0 ;
8924 char *kwnames[] = {
8925 (char *) "level",(char *) "szString",(char *) "t", NULL
8926 };
8927
8928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8929 {
8930 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8931 if (SWIG_arg_fail(1)) SWIG_fail;
8932 }
8933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(2)) SWIG_fail;
8935 {
8936 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8937 if (SWIG_arg_fail(3)) SWIG_fail;
8938 }
8939 {
8940 PyThreadState* __tstate = wxPyBeginAllowThreads();
8941 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8942
8943 wxPyEndAllowThreads(__tstate);
8944 if (PyErr_Occurred()) SWIG_fail;
8945 }
8946 Py_INCREF(Py_None); resultobj = Py_None;
8947 return resultobj;
8948 fail:
8949 return NULL;
8950 }
8951
8952
8953 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8954 PyObject *resultobj;
8955 wxLog *arg1 = (wxLog *) 0 ;
8956 PyObject * obj0 = 0 ;
8957 char *kwnames[] = {
8958 (char *) "self", NULL
8959 };
8960
8961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8963 if (SWIG_arg_fail(1)) SWIG_fail;
8964 {
8965 PyThreadState* __tstate = wxPyBeginAllowThreads();
8966 (arg1)->Flush();
8967
8968 wxPyEndAllowThreads(__tstate);
8969 if (PyErr_Occurred()) SWIG_fail;
8970 }
8971 Py_INCREF(Py_None); resultobj = Py_None;
8972 return resultobj;
8973 fail:
8974 return NULL;
8975 }
8976
8977
8978 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8979 PyObject *resultobj;
8980 char *kwnames[] = {
8981 NULL
8982 };
8983
8984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8985 {
8986 PyThreadState* __tstate = wxPyBeginAllowThreads();
8987 wxLog::FlushActive();
8988
8989 wxPyEndAllowThreads(__tstate);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 Py_INCREF(Py_None); resultobj = Py_None;
8993 return resultobj;
8994 fail:
8995 return NULL;
8996 }
8997
8998
8999 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9000 PyObject *resultobj;
9001 wxLog *result;
9002 char *kwnames[] = {
9003 NULL
9004 };
9005
9006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 result = (wxLog *)wxLog::GetActiveTarget();
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 wxLog *arg1 = (wxLog *) 0 ;
9024 wxLog *result;
9025 PyObject * obj0 = 0 ;
9026 char *kwnames[] = {
9027 (char *) "pLogger", NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
9031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9032 if (SWIG_arg_fail(1)) SWIG_fail;
9033 {
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 result = (wxLog *)wxLog::SetActiveTarget(arg1);
9036
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9048 PyObject *resultobj;
9049 char *kwnames[] = {
9050 NULL
9051 };
9052
9053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9054 {
9055 PyThreadState* __tstate = wxPyBeginAllowThreads();
9056 wxLog::Suspend();
9057
9058 wxPyEndAllowThreads(__tstate);
9059 if (PyErr_Occurred()) SWIG_fail;
9060 }
9061 Py_INCREF(Py_None); resultobj = Py_None;
9062 return resultobj;
9063 fail:
9064 return NULL;
9065 }
9066
9067
9068 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9069 PyObject *resultobj;
9070 char *kwnames[] = {
9071 NULL
9072 };
9073
9074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 wxLog::Resume();
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 Py_INCREF(Py_None); resultobj = Py_None;
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 bool arg1 = (bool) true ;
9092 PyObject * obj0 = 0 ;
9093 char *kwnames[] = {
9094 (char *) "bVerbose", NULL
9095 };
9096
9097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9098 if (obj0) {
9099 {
9100 arg1 = (bool)(SWIG_As_bool(obj0));
9101 if (SWIG_arg_fail(1)) SWIG_fail;
9102 }
9103 }
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 wxLog::SetVerbose(arg1);
9107
9108 wxPyEndAllowThreads(__tstate);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 Py_INCREF(Py_None); resultobj = Py_None;
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj;
9120 wxLogLevel arg1 ;
9121 PyObject * obj0 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "logLevel", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9127 {
9128 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9129 if (SWIG_arg_fail(1)) SWIG_fail;
9130 }
9131 {
9132 PyThreadState* __tstate = wxPyBeginAllowThreads();
9133 wxLog::SetLogLevel(arg1);
9134
9135 wxPyEndAllowThreads(__tstate);
9136 if (PyErr_Occurred()) SWIG_fail;
9137 }
9138 Py_INCREF(Py_None); resultobj = Py_None;
9139 return resultobj;
9140 fail:
9141 return NULL;
9142 }
9143
9144
9145 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9146 PyObject *resultobj;
9147 char *kwnames[] = {
9148 NULL
9149 };
9150
9151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 wxLog::DontCreateOnDemand();
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 Py_INCREF(Py_None); resultobj = Py_None;
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9167 PyObject *resultobj;
9168 wxTraceMask arg1 ;
9169 PyObject * obj0 = 0 ;
9170 char *kwnames[] = {
9171 (char *) "ulMask", NULL
9172 };
9173
9174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9175 {
9176 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9177 if (SWIG_arg_fail(1)) SWIG_fail;
9178 }
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 wxLog::SetTraceMask(arg1);
9182
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 Py_INCREF(Py_None); resultobj = Py_None;
9187 return resultobj;
9188 fail:
9189 return NULL;
9190 }
9191
9192
9193 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9194 PyObject *resultobj;
9195 wxString *arg1 = 0 ;
9196 bool temp1 = false ;
9197 PyObject * obj0 = 0 ;
9198 char *kwnames[] = {
9199 (char *) "str", NULL
9200 };
9201
9202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9203 {
9204 arg1 = wxString_in_helper(obj0);
9205 if (arg1 == NULL) SWIG_fail;
9206 temp1 = true;
9207 }
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 wxLog::AddTraceMask((wxString const &)*arg1);
9211
9212 wxPyEndAllowThreads(__tstate);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 Py_INCREF(Py_None); resultobj = Py_None;
9216 {
9217 if (temp1)
9218 delete arg1;
9219 }
9220 return resultobj;
9221 fail:
9222 {
9223 if (temp1)
9224 delete arg1;
9225 }
9226 return NULL;
9227 }
9228
9229
9230 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9231 PyObject *resultobj;
9232 wxString *arg1 = 0 ;
9233 bool temp1 = false ;
9234 PyObject * obj0 = 0 ;
9235 char *kwnames[] = {
9236 (char *) "str", NULL
9237 };
9238
9239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9240 {
9241 arg1 = wxString_in_helper(obj0);
9242 if (arg1 == NULL) SWIG_fail;
9243 temp1 = true;
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 wxLog::RemoveTraceMask((wxString const &)*arg1);
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 Py_INCREF(Py_None); resultobj = Py_None;
9253 {
9254 if (temp1)
9255 delete arg1;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp1)
9261 delete arg1;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj;
9269 char *kwnames[] = {
9270 NULL
9271 };
9272
9273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9274 {
9275 PyThreadState* __tstate = wxPyBeginAllowThreads();
9276 wxLog::ClearTraceMasks();
9277
9278 wxPyEndAllowThreads(__tstate);
9279 if (PyErr_Occurred()) SWIG_fail;
9280 }
9281 Py_INCREF(Py_None); resultobj = Py_None;
9282 return resultobj;
9283 fail:
9284 return NULL;
9285 }
9286
9287
9288 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9289 PyObject *resultobj;
9290 wxArrayString *result;
9291 char *kwnames[] = {
9292 NULL
9293 };
9294
9295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9296 {
9297 PyThreadState* __tstate = wxPyBeginAllowThreads();
9298 {
9299 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9300 result = (wxArrayString *) &_result_ref;
9301 }
9302
9303 wxPyEndAllowThreads(__tstate);
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 {
9307 resultobj = wxArrayString2PyList_helper(*result);
9308 }
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj;
9317 wxChar *arg1 = (wxChar *) 0 ;
9318 PyObject * obj0 = 0 ;
9319 char *kwnames[] = {
9320 (char *) "ts", NULL
9321 };
9322
9323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9325 if (SWIG_arg_fail(1)) SWIG_fail;
9326 {
9327 PyThreadState* __tstate = wxPyBeginAllowThreads();
9328 wxLog::SetTimestamp((wxChar const *)arg1);
9329
9330 wxPyEndAllowThreads(__tstate);
9331 if (PyErr_Occurred()) SWIG_fail;
9332 }
9333 Py_INCREF(Py_None); resultobj = Py_None;
9334 return resultobj;
9335 fail:
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 bool result;
9343 char *kwnames[] = {
9344 NULL
9345 };
9346
9347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (bool)wxLog::GetVerbose();
9351
9352 wxPyEndAllowThreads(__tstate);
9353 if (PyErr_Occurred()) SWIG_fail;
9354 }
9355 {
9356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9357 }
9358 return resultobj;
9359 fail:
9360 return NULL;
9361 }
9362
9363
9364 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9365 PyObject *resultobj;
9366 wxTraceMask result;
9367 char *kwnames[] = {
9368 NULL
9369 };
9370
9371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (wxTraceMask)wxLog::GetTraceMask();
9375
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9381 }
9382 return resultobj;
9383 fail:
9384 return NULL;
9385 }
9386
9387
9388 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9389 PyObject *resultobj;
9390 wxChar *arg1 = (wxChar *) 0 ;
9391 bool result;
9392 PyObject * obj0 = 0 ;
9393 char *kwnames[] = {
9394 (char *) "mask", NULL
9395 };
9396
9397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9399 if (SWIG_arg_fail(1)) SWIG_fail;
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9403
9404 wxPyEndAllowThreads(__tstate);
9405 if (PyErr_Occurred()) SWIG_fail;
9406 }
9407 {
9408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9409 }
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9417 PyObject *resultobj;
9418 wxLogLevel result;
9419 char *kwnames[] = {
9420 NULL
9421 };
9422
9423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (wxLogLevel)wxLog::GetLogLevel();
9427
9428 wxPyEndAllowThreads(__tstate);
9429 if (PyErr_Occurred()) SWIG_fail;
9430 }
9431 {
9432 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9433 }
9434 return resultobj;
9435 fail:
9436 return NULL;
9437 }
9438
9439
9440 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9441 PyObject *resultobj;
9442 wxChar *result;
9443 char *kwnames[] = {
9444 NULL
9445 };
9446
9447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9448 {
9449 PyThreadState* __tstate = wxPyBeginAllowThreads();
9450 result = (wxChar *)wxLog::GetTimestamp();
9451
9452 wxPyEndAllowThreads(__tstate);
9453 if (PyErr_Occurred()) SWIG_fail;
9454 }
9455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9456 return resultobj;
9457 fail:
9458 return NULL;
9459 }
9460
9461
9462 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9463 PyObject *resultobj;
9464 wxString result;
9465 char *kwnames[] = {
9466 NULL
9467 };
9468
9469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9470 {
9471 PyThreadState* __tstate = wxPyBeginAllowThreads();
9472 result = Log_TimeStamp();
9473
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 {
9478 #if wxUSE_UNICODE
9479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9480 #else
9481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9482 #endif
9483 }
9484 return resultobj;
9485 fail:
9486 return NULL;
9487 }
9488
9489
9490 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9491 PyObject *resultobj;
9492 wxLog *arg1 = (wxLog *) 0 ;
9493 PyObject * obj0 = 0 ;
9494 char *kwnames[] = {
9495 (char *) "self", NULL
9496 };
9497
9498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9500 if (SWIG_arg_fail(1)) SWIG_fail;
9501 {
9502 PyThreadState* __tstate = wxPyBeginAllowThreads();
9503 wxLog_Destroy(arg1);
9504
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 Py_INCREF(Py_None); resultobj = Py_None;
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9516 PyObject *obj;
9517 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9518 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9519 Py_INCREF(obj);
9520 return Py_BuildValue((char *)"");
9521 }
9522 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9523 PyObject *resultobj;
9524 wxLogStderr *result;
9525 char *kwnames[] = {
9526 NULL
9527 };
9528
9529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (wxLogStderr *)new wxLogStderr();
9533
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9545 PyObject *obj;
9546 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9547 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9548 Py_INCREF(obj);
9549 return Py_BuildValue((char *)"");
9550 }
9551 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9552 PyObject *resultobj;
9553 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9554 wxLogTextCtrl *result;
9555 PyObject * obj0 = 0 ;
9556 char *kwnames[] = {
9557 (char *) "pTextCtrl", NULL
9558 };
9559
9560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9562 if (SWIG_arg_fail(1)) SWIG_fail;
9563 {
9564 PyThreadState* __tstate = wxPyBeginAllowThreads();
9565 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9566
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
9577 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9578 PyObject *obj;
9579 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9580 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9581 Py_INCREF(obj);
9582 return Py_BuildValue((char *)"");
9583 }
9584 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj;
9586 wxLogGui *result;
9587 char *kwnames[] = {
9588 NULL
9589 };
9590
9591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 result = (wxLogGui *)new wxLogGui();
9595
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9607 PyObject *obj;
9608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9609 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9610 Py_INCREF(obj);
9611 return Py_BuildValue((char *)"");
9612 }
9613 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9614 PyObject *resultobj;
9615 wxFrame *arg1 = (wxFrame *) 0 ;
9616 wxString *arg2 = 0 ;
9617 bool arg3 = (bool) true ;
9618 bool arg4 = (bool) true ;
9619 wxLogWindow *result;
9620 bool temp2 = false ;
9621 PyObject * obj0 = 0 ;
9622 PyObject * obj1 = 0 ;
9623 PyObject * obj2 = 0 ;
9624 PyObject * obj3 = 0 ;
9625 char *kwnames[] = {
9626 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9627 };
9628
9629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9631 if (SWIG_arg_fail(1)) SWIG_fail;
9632 {
9633 arg2 = wxString_in_helper(obj1);
9634 if (arg2 == NULL) SWIG_fail;
9635 temp2 = true;
9636 }
9637 if (obj2) {
9638 {
9639 arg3 = (bool)(SWIG_As_bool(obj2));
9640 if (SWIG_arg_fail(3)) SWIG_fail;
9641 }
9642 }
9643 if (obj3) {
9644 {
9645 arg4 = (bool)(SWIG_As_bool(obj3));
9646 if (SWIG_arg_fail(4)) SWIG_fail;
9647 }
9648 }
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9657 {
9658 if (temp2)
9659 delete arg2;
9660 }
9661 return resultobj;
9662 fail:
9663 {
9664 if (temp2)
9665 delete arg2;
9666 }
9667 return NULL;
9668 }
9669
9670
9671 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9672 PyObject *resultobj;
9673 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9674 bool arg2 = (bool) true ;
9675 PyObject * obj0 = 0 ;
9676 PyObject * obj1 = 0 ;
9677 char *kwnames[] = {
9678 (char *) "self",(char *) "bShow", NULL
9679 };
9680
9681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9683 if (SWIG_arg_fail(1)) SWIG_fail;
9684 if (obj1) {
9685 {
9686 arg2 = (bool)(SWIG_As_bool(obj1));
9687 if (SWIG_arg_fail(2)) SWIG_fail;
9688 }
9689 }
9690 {
9691 PyThreadState* __tstate = wxPyBeginAllowThreads();
9692 (arg1)->Show(arg2);
9693
9694 wxPyEndAllowThreads(__tstate);
9695 if (PyErr_Occurred()) SWIG_fail;
9696 }
9697 Py_INCREF(Py_None); resultobj = Py_None;
9698 return resultobj;
9699 fail:
9700 return NULL;
9701 }
9702
9703
9704 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9705 PyObject *resultobj;
9706 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9707 wxFrame *result;
9708 PyObject * obj0 = 0 ;
9709 char *kwnames[] = {
9710 (char *) "self", NULL
9711 };
9712
9713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9715 if (SWIG_arg_fail(1)) SWIG_fail;
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 {
9724 resultobj = wxPyMake_wxObject(result, 0);
9725 }
9726 return resultobj;
9727 fail:
9728 return NULL;
9729 }
9730
9731
9732 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9733 PyObject *resultobj;
9734 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9735 wxLog *result;
9736 PyObject * obj0 = 0 ;
9737 char *kwnames[] = {
9738 (char *) "self", NULL
9739 };
9740
9741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9743 if (SWIG_arg_fail(1)) SWIG_fail;
9744 {
9745 PyThreadState* __tstate = wxPyBeginAllowThreads();
9746 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9747
9748 wxPyEndAllowThreads(__tstate);
9749 if (PyErr_Occurred()) SWIG_fail;
9750 }
9751 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj;
9760 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9761 bool result;
9762 PyObject * obj0 = 0 ;
9763 char *kwnames[] = {
9764 (char *) "self", NULL
9765 };
9766
9767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9769 if (SWIG_arg_fail(1)) SWIG_fail;
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9779 }
9780 return resultobj;
9781 fail:
9782 return NULL;
9783 }
9784
9785
9786 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9787 PyObject *resultobj;
9788 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9789 bool arg2 ;
9790 PyObject * obj0 = 0 ;
9791 PyObject * obj1 = 0 ;
9792 char *kwnames[] = {
9793 (char *) "self",(char *) "bDoPass", NULL
9794 };
9795
9796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(1)) SWIG_fail;
9799 {
9800 arg2 = (bool)(SWIG_As_bool(obj1));
9801 if (SWIG_arg_fail(2)) SWIG_fail;
9802 }
9803 {
9804 PyThreadState* __tstate = wxPyBeginAllowThreads();
9805 (arg1)->PassMessages(arg2);
9806
9807 wxPyEndAllowThreads(__tstate);
9808 if (PyErr_Occurred()) SWIG_fail;
9809 }
9810 Py_INCREF(Py_None); resultobj = Py_None;
9811 return resultobj;
9812 fail:
9813 return NULL;
9814 }
9815
9816
9817 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9818 PyObject *obj;
9819 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9820 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9821 Py_INCREF(obj);
9822 return Py_BuildValue((char *)"");
9823 }
9824 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9825 PyObject *resultobj;
9826 wxLog *arg1 = (wxLog *) 0 ;
9827 wxLogChain *result;
9828 PyObject * obj0 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "logger", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 PyThreadState* __tstate = wxPyBeginAllowThreads();
9838 result = (wxLogChain *)new wxLogChain(arg1);
9839
9840 wxPyEndAllowThreads(__tstate);
9841 if (PyErr_Occurred()) SWIG_fail;
9842 }
9843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9844 return resultobj;
9845 fail:
9846 return NULL;
9847 }
9848
9849
9850 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj;
9852 wxLogChain *arg1 = (wxLogChain *) 0 ;
9853 wxLog *arg2 = (wxLog *) 0 ;
9854 PyObject * obj0 = 0 ;
9855 PyObject * obj1 = 0 ;
9856 char *kwnames[] = {
9857 (char *) "self",(char *) "logger", NULL
9858 };
9859
9860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9862 if (SWIG_arg_fail(1)) SWIG_fail;
9863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(2)) SWIG_fail;
9865 {
9866 PyThreadState* __tstate = wxPyBeginAllowThreads();
9867 (arg1)->SetLog(arg2);
9868
9869 wxPyEndAllowThreads(__tstate);
9870 if (PyErr_Occurred()) SWIG_fail;
9871 }
9872 Py_INCREF(Py_None); resultobj = Py_None;
9873 return resultobj;
9874 fail:
9875 return NULL;
9876 }
9877
9878
9879 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9880 PyObject *resultobj;
9881 wxLogChain *arg1 = (wxLogChain *) 0 ;
9882 bool arg2 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char *kwnames[] = {
9886 (char *) "self",(char *) "bDoPass", NULL
9887 };
9888
9889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9891 if (SWIG_arg_fail(1)) SWIG_fail;
9892 {
9893 arg2 = (bool)(SWIG_As_bool(obj1));
9894 if (SWIG_arg_fail(2)) SWIG_fail;
9895 }
9896 {
9897 PyThreadState* __tstate = wxPyBeginAllowThreads();
9898 (arg1)->PassMessages(arg2);
9899
9900 wxPyEndAllowThreads(__tstate);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 Py_INCREF(Py_None); resultobj = Py_None;
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9911 PyObject *resultobj;
9912 wxLogChain *arg1 = (wxLogChain *) 0 ;
9913 bool result;
9914 PyObject * obj0 = 0 ;
9915 char *kwnames[] = {
9916 (char *) "self", NULL
9917 };
9918
9919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9921 if (SWIG_arg_fail(1)) SWIG_fail;
9922 {
9923 PyThreadState* __tstate = wxPyBeginAllowThreads();
9924 result = (bool)(arg1)->IsPassingMessages();
9925
9926 wxPyEndAllowThreads(__tstate);
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 {
9930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9939 PyObject *resultobj;
9940 wxLogChain *arg1 = (wxLogChain *) 0 ;
9941 wxLog *result;
9942 PyObject * obj0 = 0 ;
9943 char *kwnames[] = {
9944 (char *) "self", NULL
9945 };
9946
9947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9949 if (SWIG_arg_fail(1)) SWIG_fail;
9950 {
9951 PyThreadState* __tstate = wxPyBeginAllowThreads();
9952 result = (wxLog *)(arg1)->GetOldLog();
9953
9954 wxPyEndAllowThreads(__tstate);
9955 if (PyErr_Occurred()) SWIG_fail;
9956 }
9957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9958 return resultobj;
9959 fail:
9960 return NULL;
9961 }
9962
9963
9964 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9965 PyObject *obj;
9966 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9967 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9968 Py_INCREF(obj);
9969 return Py_BuildValue((char *)"");
9970 }
9971 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9972 PyObject *resultobj;
9973 unsigned long result;
9974 char *kwnames[] = {
9975 NULL
9976 };
9977
9978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 result = (unsigned long)wxSysErrorCode();
9982
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 {
9987 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 unsigned long arg1 = (unsigned long) 0 ;
9998 wxString result;
9999 PyObject * obj0 = 0 ;
10000 char *kwnames[] = {
10001 (char *) "nErrCode", NULL
10002 };
10003
10004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
10005 if (obj0) {
10006 {
10007 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10008 if (SWIG_arg_fail(1)) SWIG_fail;
10009 }
10010 }
10011 {
10012 PyThreadState* __tstate = wxPyBeginAllowThreads();
10013 result = wxSysErrorMsg(arg1);
10014
10015 wxPyEndAllowThreads(__tstate);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 {
10019 #if wxUSE_UNICODE
10020 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10021 #else
10022 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10023 #endif
10024 }
10025 return resultobj;
10026 fail:
10027 return NULL;
10028 }
10029
10030
10031 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
10032 PyObject *resultobj;
10033 wxString *arg1 = 0 ;
10034 bool temp1 = false ;
10035 PyObject * obj0 = 0 ;
10036 char *kwnames[] = {
10037 (char *) "msg", NULL
10038 };
10039
10040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
10041 {
10042 arg1 = wxString_in_helper(obj0);
10043 if (arg1 == NULL) SWIG_fail;
10044 temp1 = true;
10045 }
10046 {
10047 PyThreadState* __tstate = wxPyBeginAllowThreads();
10048 wxPyLogFatalError((wxString const &)*arg1);
10049
10050 wxPyEndAllowThreads(__tstate);
10051 if (PyErr_Occurred()) SWIG_fail;
10052 }
10053 Py_INCREF(Py_None); resultobj = Py_None;
10054 {
10055 if (temp1)
10056 delete arg1;
10057 }
10058 return resultobj;
10059 fail:
10060 {
10061 if (temp1)
10062 delete arg1;
10063 }
10064 return NULL;
10065 }
10066
10067
10068 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj;
10070 wxString *arg1 = 0 ;
10071 bool temp1 = false ;
10072 PyObject * obj0 = 0 ;
10073 char *kwnames[] = {
10074 (char *) "msg", NULL
10075 };
10076
10077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10078 {
10079 arg1 = wxString_in_helper(obj0);
10080 if (arg1 == NULL) SWIG_fail;
10081 temp1 = true;
10082 }
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 wxPyLogError((wxString const &)*arg1);
10086
10087 wxPyEndAllowThreads(__tstate);
10088 if (PyErr_Occurred()) SWIG_fail;
10089 }
10090 Py_INCREF(Py_None); resultobj = Py_None;
10091 {
10092 if (temp1)
10093 delete arg1;
10094 }
10095 return resultobj;
10096 fail:
10097 {
10098 if (temp1)
10099 delete arg1;
10100 }
10101 return NULL;
10102 }
10103
10104
10105 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10106 PyObject *resultobj;
10107 wxString *arg1 = 0 ;
10108 bool temp1 = false ;
10109 PyObject * obj0 = 0 ;
10110 char *kwnames[] = {
10111 (char *) "msg", NULL
10112 };
10113
10114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10115 {
10116 arg1 = wxString_in_helper(obj0);
10117 if (arg1 == NULL) SWIG_fail;
10118 temp1 = true;
10119 }
10120 {
10121 PyThreadState* __tstate = wxPyBeginAllowThreads();
10122 wxPyLogWarning((wxString const &)*arg1);
10123
10124 wxPyEndAllowThreads(__tstate);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 Py_INCREF(Py_None); resultobj = Py_None;
10128 {
10129 if (temp1)
10130 delete arg1;
10131 }
10132 return resultobj;
10133 fail:
10134 {
10135 if (temp1)
10136 delete arg1;
10137 }
10138 return NULL;
10139 }
10140
10141
10142 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10143 PyObject *resultobj;
10144 wxString *arg1 = 0 ;
10145 bool temp1 = false ;
10146 PyObject * obj0 = 0 ;
10147 char *kwnames[] = {
10148 (char *) "msg", NULL
10149 };
10150
10151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10152 {
10153 arg1 = wxString_in_helper(obj0);
10154 if (arg1 == NULL) SWIG_fail;
10155 temp1 = true;
10156 }
10157 {
10158 PyThreadState* __tstate = wxPyBeginAllowThreads();
10159 wxPyLogMessage((wxString const &)*arg1);
10160
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 Py_INCREF(Py_None); resultobj = Py_None;
10165 {
10166 if (temp1)
10167 delete arg1;
10168 }
10169 return resultobj;
10170 fail:
10171 {
10172 if (temp1)
10173 delete arg1;
10174 }
10175 return NULL;
10176 }
10177
10178
10179 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj;
10181 wxString *arg1 = 0 ;
10182 bool temp1 = false ;
10183 PyObject * obj0 = 0 ;
10184 char *kwnames[] = {
10185 (char *) "msg", NULL
10186 };
10187
10188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10189 {
10190 arg1 = wxString_in_helper(obj0);
10191 if (arg1 == NULL) SWIG_fail;
10192 temp1 = true;
10193 }
10194 {
10195 PyThreadState* __tstate = wxPyBeginAllowThreads();
10196 wxPyLogInfo((wxString const &)*arg1);
10197
10198 wxPyEndAllowThreads(__tstate);
10199 if (PyErr_Occurred()) SWIG_fail;
10200 }
10201 Py_INCREF(Py_None); resultobj = Py_None;
10202 {
10203 if (temp1)
10204 delete arg1;
10205 }
10206 return resultobj;
10207 fail:
10208 {
10209 if (temp1)
10210 delete arg1;
10211 }
10212 return NULL;
10213 }
10214
10215
10216 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxString *arg1 = 0 ;
10219 bool temp1 = false ;
10220 PyObject * obj0 = 0 ;
10221 char *kwnames[] = {
10222 (char *) "msg", NULL
10223 };
10224
10225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10226 {
10227 arg1 = wxString_in_helper(obj0);
10228 if (arg1 == NULL) SWIG_fail;
10229 temp1 = true;
10230 }
10231 {
10232 PyThreadState* __tstate = wxPyBeginAllowThreads();
10233 wxPyLogDebug((wxString const &)*arg1);
10234
10235 wxPyEndAllowThreads(__tstate);
10236 if (PyErr_Occurred()) SWIG_fail;
10237 }
10238 Py_INCREF(Py_None); resultobj = Py_None;
10239 {
10240 if (temp1)
10241 delete arg1;
10242 }
10243 return resultobj;
10244 fail:
10245 {
10246 if (temp1)
10247 delete arg1;
10248 }
10249 return NULL;
10250 }
10251
10252
10253 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10254 PyObject *resultobj;
10255 wxString *arg1 = 0 ;
10256 bool temp1 = false ;
10257 PyObject * obj0 = 0 ;
10258 char *kwnames[] = {
10259 (char *) "msg", NULL
10260 };
10261
10262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10263 {
10264 arg1 = wxString_in_helper(obj0);
10265 if (arg1 == NULL) SWIG_fail;
10266 temp1 = true;
10267 }
10268 {
10269 PyThreadState* __tstate = wxPyBeginAllowThreads();
10270 wxPyLogVerbose((wxString const &)*arg1);
10271
10272 wxPyEndAllowThreads(__tstate);
10273 if (PyErr_Occurred()) SWIG_fail;
10274 }
10275 Py_INCREF(Py_None); resultobj = Py_None;
10276 {
10277 if (temp1)
10278 delete arg1;
10279 }
10280 return resultobj;
10281 fail:
10282 {
10283 if (temp1)
10284 delete arg1;
10285 }
10286 return NULL;
10287 }
10288
10289
10290 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj;
10292 wxString *arg1 = 0 ;
10293 bool temp1 = false ;
10294 PyObject * obj0 = 0 ;
10295 char *kwnames[] = {
10296 (char *) "msg", NULL
10297 };
10298
10299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10300 {
10301 arg1 = wxString_in_helper(obj0);
10302 if (arg1 == NULL) SWIG_fail;
10303 temp1 = true;
10304 }
10305 {
10306 PyThreadState* __tstate = wxPyBeginAllowThreads();
10307 wxPyLogStatus((wxString const &)*arg1);
10308
10309 wxPyEndAllowThreads(__tstate);
10310 if (PyErr_Occurred()) SWIG_fail;
10311 }
10312 Py_INCREF(Py_None); resultobj = Py_None;
10313 {
10314 if (temp1)
10315 delete arg1;
10316 }
10317 return resultobj;
10318 fail:
10319 {
10320 if (temp1)
10321 delete arg1;
10322 }
10323 return NULL;
10324 }
10325
10326
10327 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10328 PyObject *resultobj;
10329 wxFrame *arg1 = (wxFrame *) 0 ;
10330 wxString *arg2 = 0 ;
10331 bool temp2 = false ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 char *kwnames[] = {
10335 (char *) "pFrame",(char *) "msg", NULL
10336 };
10337
10338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10340 if (SWIG_arg_fail(1)) SWIG_fail;
10341 {
10342 arg2 = wxString_in_helper(obj1);
10343 if (arg2 == NULL) SWIG_fail;
10344 temp2 = true;
10345 }
10346 {
10347 PyThreadState* __tstate = wxPyBeginAllowThreads();
10348 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10349
10350 wxPyEndAllowThreads(__tstate);
10351 if (PyErr_Occurred()) SWIG_fail;
10352 }
10353 Py_INCREF(Py_None); resultobj = Py_None;
10354 {
10355 if (temp2)
10356 delete arg2;
10357 }
10358 return resultobj;
10359 fail:
10360 {
10361 if (temp2)
10362 delete arg2;
10363 }
10364 return NULL;
10365 }
10366
10367
10368 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj;
10370 wxString *arg1 = 0 ;
10371 bool temp1 = false ;
10372 PyObject * obj0 = 0 ;
10373 char *kwnames[] = {
10374 (char *) "msg", NULL
10375 };
10376
10377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10378 {
10379 arg1 = wxString_in_helper(obj0);
10380 if (arg1 == NULL) SWIG_fail;
10381 temp1 = true;
10382 }
10383 {
10384 PyThreadState* __tstate = wxPyBeginAllowThreads();
10385 wxPyLogSysError((wxString const &)*arg1);
10386
10387 wxPyEndAllowThreads(__tstate);
10388 if (PyErr_Occurred()) SWIG_fail;
10389 }
10390 Py_INCREF(Py_None); resultobj = Py_None;
10391 {
10392 if (temp1)
10393 delete arg1;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp1)
10399 delete arg1;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj;
10407 unsigned long arg1 ;
10408 wxString *arg2 = 0 ;
10409 bool temp2 = false ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 char *kwnames[] = {
10413 (char *) "level",(char *) "msg", NULL
10414 };
10415
10416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10417 {
10418 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10419 if (SWIG_arg_fail(1)) SWIG_fail;
10420 }
10421 {
10422 arg2 = wxString_in_helper(obj1);
10423 if (arg2 == NULL) SWIG_fail;
10424 temp2 = true;
10425 }
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10429
10430 wxPyEndAllowThreads(__tstate);
10431 if (PyErr_Occurred()) SWIG_fail;
10432 }
10433 Py_INCREF(Py_None); resultobj = Py_None;
10434 {
10435 if (temp2)
10436 delete arg2;
10437 }
10438 return resultobj;
10439 fail:
10440 {
10441 if (temp2)
10442 delete arg2;
10443 }
10444 return NULL;
10445 }
10446
10447
10448 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10449 PyObject *resultobj;
10450 unsigned long arg1 ;
10451 wxString *arg2 = 0 ;
10452 bool temp2 = false ;
10453 PyObject * obj0 = 0 ;
10454 PyObject * obj1 = 0 ;
10455
10456 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&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 wxPyLogTrace(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_1(PyObject *, PyObject *args) {
10489 PyObject *resultobj;
10490 wxString *arg1 = 0 ;
10491 wxString *arg2 = 0 ;
10492 bool temp1 = false ;
10493 bool temp2 = false ;
10494 PyObject * obj0 = 0 ;
10495 PyObject * obj1 = 0 ;
10496
10497 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10498 {
10499 arg1 = wxString_in_helper(obj0);
10500 if (arg1 == NULL) SWIG_fail;
10501 temp1 = true;
10502 }
10503 {
10504 arg2 = wxString_in_helper(obj1);
10505 if (arg2 == NULL) SWIG_fail;
10506 temp2 = true;
10507 }
10508 {
10509 PyThreadState* __tstate = wxPyBeginAllowThreads();
10510 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10511
10512 wxPyEndAllowThreads(__tstate);
10513 if (PyErr_Occurred()) SWIG_fail;
10514 }
10515 Py_INCREF(Py_None); resultobj = Py_None;
10516 {
10517 if (temp1)
10518 delete arg1;
10519 }
10520 {
10521 if (temp2)
10522 delete arg2;
10523 }
10524 return resultobj;
10525 fail:
10526 {
10527 if (temp1)
10528 delete arg1;
10529 }
10530 {
10531 if (temp2)
10532 delete arg2;
10533 }
10534 return NULL;
10535 }
10536
10537
10538 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10539 int argc;
10540 PyObject *argv[3];
10541 int ii;
10542
10543 argc = PyObject_Length(args);
10544 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10545 argv[ii] = PyTuple_GetItem(args,ii);
10546 }
10547 if (argc == 2) {
10548 int _v;
10549 {
10550 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10551 }
10552 if (_v) {
10553 {
10554 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10555 }
10556 if (_v) {
10557 return _wrap_LogTrace__SWIG_1(self,args);
10558 }
10559 }
10560 }
10561 if (argc == 2) {
10562 int _v;
10563 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10564 if (_v) {
10565 {
10566 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10567 }
10568 if (_v) {
10569 return _wrap_LogTrace__SWIG_0(self,args);
10570 }
10571 }
10572 }
10573
10574 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10575 return NULL;
10576 }
10577
10578
10579 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10580 PyObject *resultobj;
10581 wxString *arg1 = 0 ;
10582 wxString *arg2 = 0 ;
10583 bool temp1 = false ;
10584 bool temp2 = false ;
10585 PyObject * obj0 = 0 ;
10586 PyObject * obj1 = 0 ;
10587 char *kwnames[] = {
10588 (char *) "title",(char *) "text", NULL
10589 };
10590
10591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10592 {
10593 arg1 = wxString_in_helper(obj0);
10594 if (arg1 == NULL) SWIG_fail;
10595 temp1 = true;
10596 }
10597 {
10598 arg2 = wxString_in_helper(obj1);
10599 if (arg2 == NULL) SWIG_fail;
10600 temp2 = true;
10601 }
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10605
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 Py_INCREF(Py_None); resultobj = Py_None;
10610 {
10611 if (temp1)
10612 delete arg1;
10613 }
10614 {
10615 if (temp2)
10616 delete arg2;
10617 }
10618 return resultobj;
10619 fail:
10620 {
10621 if (temp1)
10622 delete arg1;
10623 }
10624 {
10625 if (temp2)
10626 delete arg2;
10627 }
10628 return NULL;
10629 }
10630
10631
10632 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10633 PyObject *resultobj;
10634 wxLogNull *result;
10635 char *kwnames[] = {
10636 NULL
10637 };
10638
10639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10640 {
10641 PyThreadState* __tstate = wxPyBeginAllowThreads();
10642 result = (wxLogNull *)new wxLogNull();
10643
10644 wxPyEndAllowThreads(__tstate);
10645 if (PyErr_Occurred()) SWIG_fail;
10646 }
10647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10648 return resultobj;
10649 fail:
10650 return NULL;
10651 }
10652
10653
10654 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10655 PyObject *resultobj;
10656 wxLogNull *arg1 = (wxLogNull *) 0 ;
10657 PyObject * obj0 = 0 ;
10658 char *kwnames[] = {
10659 (char *) "self", NULL
10660 };
10661
10662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10664 if (SWIG_arg_fail(1)) SWIG_fail;
10665 {
10666 PyThreadState* __tstate = wxPyBeginAllowThreads();
10667 delete arg1;
10668
10669 wxPyEndAllowThreads(__tstate);
10670 if (PyErr_Occurred()) SWIG_fail;
10671 }
10672 Py_INCREF(Py_None); resultobj = Py_None;
10673 return resultobj;
10674 fail:
10675 return NULL;
10676 }
10677
10678
10679 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10680 PyObject *obj;
10681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10682 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10683 Py_INCREF(obj);
10684 return Py_BuildValue((char *)"");
10685 }
10686 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10687 PyObject *resultobj;
10688 wxPyLog *result;
10689 char *kwnames[] = {
10690 NULL
10691 };
10692
10693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 result = (wxPyLog *)new wxPyLog();
10697
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10702 return resultobj;
10703 fail:
10704 return NULL;
10705 }
10706
10707
10708 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10709 PyObject *resultobj;
10710 wxPyLog *arg1 = (wxPyLog *) 0 ;
10711 PyObject *arg2 = (PyObject *) 0 ;
10712 PyObject *arg3 = (PyObject *) 0 ;
10713 PyObject * obj0 = 0 ;
10714 PyObject * obj1 = 0 ;
10715 PyObject * obj2 = 0 ;
10716 char *kwnames[] = {
10717 (char *) "self",(char *) "self",(char *) "_class", NULL
10718 };
10719
10720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10722 if (SWIG_arg_fail(1)) SWIG_fail;
10723 arg2 = obj1;
10724 arg3 = obj2;
10725 {
10726 PyThreadState* __tstate = wxPyBeginAllowThreads();
10727 (arg1)->_setCallbackInfo(arg2,arg3);
10728
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 Py_INCREF(Py_None); resultobj = Py_None;
10733 return resultobj;
10734 fail:
10735 return NULL;
10736 }
10737
10738
10739 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10740 PyObject *obj;
10741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10742 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10743 Py_INCREF(obj);
10744 return Py_BuildValue((char *)"");
10745 }
10746 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj;
10748 int arg1 ;
10749 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10750 int arg3 = (int) wxKILL_NOCHILDREN ;
10751 wxKillError result;
10752 PyObject * obj0 = 0 ;
10753 PyObject * obj1 = 0 ;
10754 PyObject * obj2 = 0 ;
10755 char *kwnames[] = {
10756 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10757 };
10758
10759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10760 {
10761 arg1 = (int)(SWIG_As_int(obj0));
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 }
10764 if (obj1) {
10765 {
10766 arg2 = (wxSignal)(SWIG_As_int(obj1));
10767 if (SWIG_arg_fail(2)) SWIG_fail;
10768 }
10769 }
10770 if (obj2) {
10771 {
10772 arg3 = (int)(SWIG_As_int(obj2));
10773 if (SWIG_arg_fail(3)) SWIG_fail;
10774 }
10775 }
10776 {
10777 PyThreadState* __tstate = wxPyBeginAllowThreads();
10778 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10779
10780 wxPyEndAllowThreads(__tstate);
10781 if (PyErr_Occurred()) SWIG_fail;
10782 }
10783 resultobj = SWIG_From_int((result));
10784 return resultobj;
10785 fail:
10786 return NULL;
10787 }
10788
10789
10790 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10791 PyObject *resultobj;
10792 int arg1 ;
10793 bool result;
10794 PyObject * obj0 = 0 ;
10795 char *kwnames[] = {
10796 (char *) "pid", NULL
10797 };
10798
10799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10800 {
10801 arg1 = (int)(SWIG_As_int(obj0));
10802 if (SWIG_arg_fail(1)) SWIG_fail;
10803 }
10804 {
10805 PyThreadState* __tstate = wxPyBeginAllowThreads();
10806 result = (bool)wxPyProcess::Exists(arg1);
10807
10808 wxPyEndAllowThreads(__tstate);
10809 if (PyErr_Occurred()) SWIG_fail;
10810 }
10811 {
10812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10813 }
10814 return resultobj;
10815 fail:
10816 return NULL;
10817 }
10818
10819
10820 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10821 PyObject *resultobj;
10822 wxString *arg1 = 0 ;
10823 int arg2 = (int) wxEXEC_ASYNC ;
10824 wxPyProcess *result;
10825 bool temp1 = false ;
10826 PyObject * obj0 = 0 ;
10827 PyObject * obj1 = 0 ;
10828 char *kwnames[] = {
10829 (char *) "cmd",(char *) "flags", NULL
10830 };
10831
10832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10833 {
10834 arg1 = wxString_in_helper(obj0);
10835 if (arg1 == NULL) SWIG_fail;
10836 temp1 = true;
10837 }
10838 if (obj1) {
10839 {
10840 arg2 = (int)(SWIG_As_int(obj1));
10841 if (SWIG_arg_fail(2)) SWIG_fail;
10842 }
10843 }
10844 {
10845 PyThreadState* __tstate = wxPyBeginAllowThreads();
10846 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10847
10848 wxPyEndAllowThreads(__tstate);
10849 if (PyErr_Occurred()) SWIG_fail;
10850 }
10851 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10852 {
10853 if (temp1)
10854 delete arg1;
10855 }
10856 return resultobj;
10857 fail:
10858 {
10859 if (temp1)
10860 delete arg1;
10861 }
10862 return NULL;
10863 }
10864
10865
10866 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj;
10868 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10869 int arg2 = (int) -1 ;
10870 wxPyProcess *result;
10871 PyObject * obj0 = 0 ;
10872 PyObject * obj1 = 0 ;
10873 char *kwnames[] = {
10874 (char *) "parent",(char *) "id", NULL
10875 };
10876
10877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10878 if (obj0) {
10879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 }
10882 if (obj1) {
10883 {
10884 arg2 = (int)(SWIG_As_int(obj1));
10885 if (SWIG_arg_fail(2)) SWIG_fail;
10886 }
10887 }
10888 {
10889 PyThreadState* __tstate = wxPyBeginAllowThreads();
10890 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10891
10892 wxPyEndAllowThreads(__tstate);
10893 if (PyErr_Occurred()) SWIG_fail;
10894 }
10895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10896 return resultobj;
10897 fail:
10898 return NULL;
10899 }
10900
10901
10902 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10903 PyObject *resultobj;
10904 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10905 PyObject *arg2 = (PyObject *) 0 ;
10906 PyObject *arg3 = (PyObject *) 0 ;
10907 PyObject * obj0 = 0 ;
10908 PyObject * obj1 = 0 ;
10909 PyObject * obj2 = 0 ;
10910 char *kwnames[] = {
10911 (char *) "self",(char *) "self",(char *) "_class", NULL
10912 };
10913
10914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10916 if (SWIG_arg_fail(1)) SWIG_fail;
10917 arg2 = obj1;
10918 arg3 = obj2;
10919 {
10920 PyThreadState* __tstate = wxPyBeginAllowThreads();
10921 (arg1)->_setCallbackInfo(arg2,arg3);
10922
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 Py_INCREF(Py_None); resultobj = Py_None;
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj;
10935 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10936 int arg2 ;
10937 int arg3 ;
10938 PyObject * obj0 = 0 ;
10939 PyObject * obj1 = 0 ;
10940 PyObject * obj2 = 0 ;
10941 char *kwnames[] = {
10942 (char *) "self",(char *) "pid",(char *) "status", NULL
10943 };
10944
10945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10947 if (SWIG_arg_fail(1)) SWIG_fail;
10948 {
10949 arg2 = (int)(SWIG_As_int(obj1));
10950 if (SWIG_arg_fail(2)) SWIG_fail;
10951 }
10952 {
10953 arg3 = (int)(SWIG_As_int(obj2));
10954 if (SWIG_arg_fail(3)) SWIG_fail;
10955 }
10956 {
10957 PyThreadState* __tstate = wxPyBeginAllowThreads();
10958 (arg1)->base_OnTerminate(arg2,arg3);
10959
10960 wxPyEndAllowThreads(__tstate);
10961 if (PyErr_Occurred()) SWIG_fail;
10962 }
10963 Py_INCREF(Py_None); resultobj = Py_None;
10964 return resultobj;
10965 fail:
10966 return NULL;
10967 }
10968
10969
10970 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10971 PyObject *resultobj;
10972 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10973 PyObject * obj0 = 0 ;
10974 char *kwnames[] = {
10975 (char *) "self", NULL
10976 };
10977
10978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10980 if (SWIG_arg_fail(1)) SWIG_fail;
10981 {
10982 PyThreadState* __tstate = wxPyBeginAllowThreads();
10983 (arg1)->Redirect();
10984
10985 wxPyEndAllowThreads(__tstate);
10986 if (PyErr_Occurred()) SWIG_fail;
10987 }
10988 Py_INCREF(Py_None); resultobj = Py_None;
10989 return resultobj;
10990 fail:
10991 return NULL;
10992 }
10993
10994
10995 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10996 PyObject *resultobj;
10997 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10998 bool result;
10999 PyObject * obj0 = 0 ;
11000 char *kwnames[] = {
11001 (char *) "self", NULL
11002 };
11003
11004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
11005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11006 if (SWIG_arg_fail(1)) SWIG_fail;
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (bool)(arg1)->IsRedirected();
11010
11011 wxPyEndAllowThreads(__tstate);
11012 if (PyErr_Occurred()) SWIG_fail;
11013 }
11014 {
11015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11016 }
11017 return resultobj;
11018 fail:
11019 return NULL;
11020 }
11021
11022
11023 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
11024 PyObject *resultobj;
11025 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11026 PyObject * obj0 = 0 ;
11027 char *kwnames[] = {
11028 (char *) "self", NULL
11029 };
11030
11031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
11032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11033 if (SWIG_arg_fail(1)) SWIG_fail;
11034 {
11035 PyThreadState* __tstate = wxPyBeginAllowThreads();
11036 (arg1)->Detach();
11037
11038 wxPyEndAllowThreads(__tstate);
11039 if (PyErr_Occurred()) SWIG_fail;
11040 }
11041 Py_INCREF(Py_None); resultobj = Py_None;
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj;
11050 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11051 wxInputStream *result;
11052 PyObject * obj0 = 0 ;
11053 char *kwnames[] = {
11054 (char *) "self", NULL
11055 };
11056
11057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11059 if (SWIG_arg_fail(1)) SWIG_fail;
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 result = (wxInputStream *)(arg1)->GetInputStream();
11063
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 {
11068 wxPyInputStream * _ptr = NULL;
11069
11070 if (result) {
11071 _ptr = new wxPyInputStream(result);
11072 }
11073 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11074 }
11075 return resultobj;
11076 fail:
11077 return NULL;
11078 }
11079
11080
11081 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11082 PyObject *resultobj;
11083 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11084 wxInputStream *result;
11085 PyObject * obj0 = 0 ;
11086 char *kwnames[] = {
11087 (char *) "self", NULL
11088 };
11089
11090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11092 if (SWIG_arg_fail(1)) SWIG_fail;
11093 {
11094 PyThreadState* __tstate = wxPyBeginAllowThreads();
11095 result = (wxInputStream *)(arg1)->GetErrorStream();
11096
11097 wxPyEndAllowThreads(__tstate);
11098 if (PyErr_Occurred()) SWIG_fail;
11099 }
11100 {
11101 wxPyInputStream * _ptr = NULL;
11102
11103 if (result) {
11104 _ptr = new wxPyInputStream(result);
11105 }
11106 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11107 }
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11115 PyObject *resultobj;
11116 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11117 wxOutputStream *result;
11118 PyObject * obj0 = 0 ;
11119 char *kwnames[] = {
11120 (char *) "self", NULL
11121 };
11122
11123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11125 if (SWIG_arg_fail(1)) SWIG_fail;
11126 {
11127 PyThreadState* __tstate = wxPyBeginAllowThreads();
11128 result = (wxOutputStream *)(arg1)->GetOutputStream();
11129
11130 wxPyEndAllowThreads(__tstate);
11131 if (PyErr_Occurred()) SWIG_fail;
11132 }
11133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11134 return resultobj;
11135 fail:
11136 return NULL;
11137 }
11138
11139
11140 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11141 PyObject *resultobj;
11142 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11143 PyObject * obj0 = 0 ;
11144 char *kwnames[] = {
11145 (char *) "self", NULL
11146 };
11147
11148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11150 if (SWIG_arg_fail(1)) SWIG_fail;
11151 {
11152 PyThreadState* __tstate = wxPyBeginAllowThreads();
11153 (arg1)->CloseOutput();
11154
11155 wxPyEndAllowThreads(__tstate);
11156 if (PyErr_Occurred()) SWIG_fail;
11157 }
11158 Py_INCREF(Py_None); resultobj = Py_None;
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11168 bool result;
11169 PyObject * obj0 = 0 ;
11170 char *kwnames[] = {
11171 (char *) "self", NULL
11172 };
11173
11174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11176 if (SWIG_arg_fail(1)) SWIG_fail;
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11180
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11194 PyObject *resultobj;
11195 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11196 bool result;
11197 PyObject * obj0 = 0 ;
11198 char *kwnames[] = {
11199 (char *) "self", NULL
11200 };
11201
11202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11204 if (SWIG_arg_fail(1)) SWIG_fail;
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11208
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 {
11213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11214 }
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11222 PyObject *resultobj;
11223 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11224 bool result;
11225 PyObject * obj0 = 0 ;
11226 char *kwnames[] = {
11227 (char *) "self", NULL
11228 };
11229
11230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11232 if (SWIG_arg_fail(1)) SWIG_fail;
11233 {
11234 PyThreadState* __tstate = wxPyBeginAllowThreads();
11235 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11236
11237 wxPyEndAllowThreads(__tstate);
11238 if (PyErr_Occurred()) SWIG_fail;
11239 }
11240 {
11241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11242 }
11243 return resultobj;
11244 fail:
11245 return NULL;
11246 }
11247
11248
11249 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11250 PyObject *obj;
11251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11252 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11253 Py_INCREF(obj);
11254 return Py_BuildValue((char *)"");
11255 }
11256 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11257 PyObject *resultobj;
11258 int arg1 = (int) 0 ;
11259 int arg2 = (int) 0 ;
11260 int arg3 = (int) 0 ;
11261 wxProcessEvent *result;
11262 PyObject * obj0 = 0 ;
11263 PyObject * obj1 = 0 ;
11264 PyObject * obj2 = 0 ;
11265 char *kwnames[] = {
11266 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11267 };
11268
11269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11270 if (obj0) {
11271 {
11272 arg1 = (int)(SWIG_As_int(obj0));
11273 if (SWIG_arg_fail(1)) SWIG_fail;
11274 }
11275 }
11276 if (obj1) {
11277 {
11278 arg2 = (int)(SWIG_As_int(obj1));
11279 if (SWIG_arg_fail(2)) SWIG_fail;
11280 }
11281 }
11282 if (obj2) {
11283 {
11284 arg3 = (int)(SWIG_As_int(obj2));
11285 if (SWIG_arg_fail(3)) SWIG_fail;
11286 }
11287 }
11288 {
11289 PyThreadState* __tstate = wxPyBeginAllowThreads();
11290 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11291
11292 wxPyEndAllowThreads(__tstate);
11293 if (PyErr_Occurred()) SWIG_fail;
11294 }
11295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11296 return resultobj;
11297 fail:
11298 return NULL;
11299 }
11300
11301
11302 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11303 PyObject *resultobj;
11304 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11305 int result;
11306 PyObject * obj0 = 0 ;
11307 char *kwnames[] = {
11308 (char *) "self", NULL
11309 };
11310
11311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11313 if (SWIG_arg_fail(1)) SWIG_fail;
11314 {
11315 PyThreadState* __tstate = wxPyBeginAllowThreads();
11316 result = (int)(arg1)->GetPid();
11317
11318 wxPyEndAllowThreads(__tstate);
11319 if (PyErr_Occurred()) SWIG_fail;
11320 }
11321 {
11322 resultobj = SWIG_From_int((int)(result));
11323 }
11324 return resultobj;
11325 fail:
11326 return NULL;
11327 }
11328
11329
11330 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11331 PyObject *resultobj;
11332 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11333 int result;
11334 PyObject * obj0 = 0 ;
11335 char *kwnames[] = {
11336 (char *) "self", NULL
11337 };
11338
11339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11341 if (SWIG_arg_fail(1)) SWIG_fail;
11342 {
11343 PyThreadState* __tstate = wxPyBeginAllowThreads();
11344 result = (int)(arg1)->GetExitCode();
11345
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 resultobj = SWIG_From_int((int)(result));
11351 }
11352 return resultobj;
11353 fail:
11354 return NULL;
11355 }
11356
11357
11358 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj;
11360 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11361 int arg2 ;
11362 PyObject * obj0 = 0 ;
11363 PyObject * obj1 = 0 ;
11364 char *kwnames[] = {
11365 (char *) "self",(char *) "m_pid", NULL
11366 };
11367
11368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11370 if (SWIG_arg_fail(1)) SWIG_fail;
11371 {
11372 arg2 = (int)(SWIG_As_int(obj1));
11373 if (SWIG_arg_fail(2)) SWIG_fail;
11374 }
11375 if (arg1) (arg1)->m_pid = arg2;
11376
11377 Py_INCREF(Py_None); resultobj = Py_None;
11378 return resultobj;
11379 fail:
11380 return NULL;
11381 }
11382
11383
11384 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11385 PyObject *resultobj;
11386 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11387 int result;
11388 PyObject * obj0 = 0 ;
11389 char *kwnames[] = {
11390 (char *) "self", NULL
11391 };
11392
11393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11395 if (SWIG_arg_fail(1)) SWIG_fail;
11396 result = (int) ((arg1)->m_pid);
11397
11398 {
11399 resultobj = SWIG_From_int((int)(result));
11400 }
11401 return resultobj;
11402 fail:
11403 return NULL;
11404 }
11405
11406
11407 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11410 int arg2 ;
11411 PyObject * obj0 = 0 ;
11412 PyObject * obj1 = 0 ;
11413 char *kwnames[] = {
11414 (char *) "self",(char *) "m_exitcode", NULL
11415 };
11416
11417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11419 if (SWIG_arg_fail(1)) SWIG_fail;
11420 {
11421 arg2 = (int)(SWIG_As_int(obj1));
11422 if (SWIG_arg_fail(2)) SWIG_fail;
11423 }
11424 if (arg1) (arg1)->m_exitcode = arg2;
11425
11426 Py_INCREF(Py_None); resultobj = Py_None;
11427 return resultobj;
11428 fail:
11429 return NULL;
11430 }
11431
11432
11433 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11434 PyObject *resultobj;
11435 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11436 int result;
11437 PyObject * obj0 = 0 ;
11438 char *kwnames[] = {
11439 (char *) "self", NULL
11440 };
11441
11442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11444 if (SWIG_arg_fail(1)) SWIG_fail;
11445 result = (int) ((arg1)->m_exitcode);
11446
11447 {
11448 resultobj = SWIG_From_int((int)(result));
11449 }
11450 return resultobj;
11451 fail:
11452 return NULL;
11453 }
11454
11455
11456 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11457 PyObject *obj;
11458 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11459 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11460 Py_INCREF(obj);
11461 return Py_BuildValue((char *)"");
11462 }
11463 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 wxString *arg1 = 0 ;
11466 int arg2 = (int) wxEXEC_ASYNC ;
11467 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11468 long result;
11469 bool temp1 = false ;
11470 PyObject * obj0 = 0 ;
11471 PyObject * obj1 = 0 ;
11472 PyObject * obj2 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "command",(char *) "flags",(char *) "process", NULL
11475 };
11476
11477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11478 {
11479 arg1 = wxString_in_helper(obj0);
11480 if (arg1 == NULL) SWIG_fail;
11481 temp1 = true;
11482 }
11483 if (obj1) {
11484 {
11485 arg2 = (int)(SWIG_As_int(obj1));
11486 if (SWIG_arg_fail(2)) SWIG_fail;
11487 }
11488 }
11489 if (obj2) {
11490 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11491 if (SWIG_arg_fail(3)) SWIG_fail;
11492 }
11493 {
11494 if (!wxPyCheckForApp()) SWIG_fail;
11495 PyThreadState* __tstate = wxPyBeginAllowThreads();
11496 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11497
11498 wxPyEndAllowThreads(__tstate);
11499 if (PyErr_Occurred()) SWIG_fail;
11500 }
11501 {
11502 resultobj = SWIG_From_long((long)(result));
11503 }
11504 {
11505 if (temp1)
11506 delete arg1;
11507 }
11508 return resultobj;
11509 fail:
11510 {
11511 if (temp1)
11512 delete arg1;
11513 }
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 long arg1 ;
11521 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11522 wxKillError *arg3 = (wxKillError *) 0 ;
11523 int arg4 = (int) wxKILL_NOCHILDREN ;
11524 int result;
11525 wxKillError temp3 ;
11526 PyObject * obj0 = 0 ;
11527 PyObject * obj1 = 0 ;
11528 PyObject * obj2 = 0 ;
11529 char *kwnames[] = {
11530 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11531 };
11532
11533 {
11534 arg3 = &temp3;
11535 }
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11537 {
11538 arg1 = (long)(SWIG_As_long(obj0));
11539 if (SWIG_arg_fail(1)) SWIG_fail;
11540 }
11541 if (obj1) {
11542 {
11543 arg2 = (wxSignal)(SWIG_As_int(obj1));
11544 if (SWIG_arg_fail(2)) SWIG_fail;
11545 }
11546 }
11547 if (obj2) {
11548 {
11549 arg4 = (int)(SWIG_As_int(obj2));
11550 if (SWIG_arg_fail(4)) SWIG_fail;
11551 }
11552 }
11553 {
11554 PyThreadState* __tstate = wxPyBeginAllowThreads();
11555 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11556
11557 wxPyEndAllowThreads(__tstate);
11558 if (PyErr_Occurred()) SWIG_fail;
11559 }
11560 {
11561 resultobj = SWIG_From_int((int)(result));
11562 }
11563 {
11564 PyObject* o;
11565 o = PyInt_FromLong((long) (*arg3));
11566 resultobj = t_output_helper(resultobj, o);
11567 }
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 int arg1 = (int) wxJOYSTICK1 ;
11577 wxJoystick *result;
11578 PyObject * obj0 = 0 ;
11579 char *kwnames[] = {
11580 (char *) "joystick", NULL
11581 };
11582
11583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11584 if (obj0) {
11585 {
11586 arg1 = (int)(SWIG_As_int(obj0));
11587 if (SWIG_arg_fail(1)) SWIG_fail;
11588 }
11589 }
11590 {
11591 if (!wxPyCheckForApp()) SWIG_fail;
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = (wxJoystick *)new wxJoystick(arg1);
11594
11595 wxPyEndAllowThreads(__tstate);
11596 if (PyErr_Occurred()) SWIG_fail;
11597 }
11598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11599 return resultobj;
11600 fail:
11601 return NULL;
11602 }
11603
11604
11605 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11606 PyObject *resultobj;
11607 wxJoystick *arg1 = (wxJoystick *) 0 ;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 delete arg1;
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 Py_INCREF(Py_None); resultobj = Py_None;
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj;
11632 wxJoystick *arg1 = (wxJoystick *) 0 ;
11633 wxPoint result;
11634 PyObject * obj0 = 0 ;
11635 char *kwnames[] = {
11636 (char *) "self", NULL
11637 };
11638
11639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11641 if (SWIG_arg_fail(1)) SWIG_fail;
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = (arg1)->GetPosition();
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 {
11650 wxPoint * resultptr;
11651 resultptr = new wxPoint((wxPoint &)(result));
11652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj;
11662 wxJoystick *arg1 = (wxJoystick *) 0 ;
11663 int result;
11664 PyObject * obj0 = 0 ;
11665 char *kwnames[] = {
11666 (char *) "self", NULL
11667 };
11668
11669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11671 if (SWIG_arg_fail(1)) SWIG_fail;
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (int)(arg1)->GetZPosition();
11675
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 {
11680 resultobj = SWIG_From_int((int)(result));
11681 }
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj;
11690 wxJoystick *arg1 = (wxJoystick *) 0 ;
11691 int result;
11692 PyObject * obj0 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (int)(arg1)->GetButtonState();
11703
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 resultobj = SWIG_From_int((int)(result));
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj;
11718 wxJoystick *arg1 = (wxJoystick *) 0 ;
11719 int result;
11720 PyObject * obj0 = 0 ;
11721 char *kwnames[] = {
11722 (char *) "self", NULL
11723 };
11724
11725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11727 if (SWIG_arg_fail(1)) SWIG_fail;
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (int)(arg1)->GetPOVPosition();
11731
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 {
11736 resultobj = SWIG_From_int((int)(result));
11737 }
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj;
11746 wxJoystick *arg1 = (wxJoystick *) 0 ;
11747 int result;
11748 PyObject * obj0 = 0 ;
11749 char *kwnames[] = {
11750 (char *) "self", NULL
11751 };
11752
11753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11755 if (SWIG_arg_fail(1)) SWIG_fail;
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (int)(arg1)->GetPOVCTSPosition();
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 {
11764 resultobj = SWIG_From_int((int)(result));
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj;
11774 wxJoystick *arg1 = (wxJoystick *) 0 ;
11775 int result;
11776 PyObject * obj0 = 0 ;
11777 char *kwnames[] = {
11778 (char *) "self", NULL
11779 };
11780
11781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11783 if (SWIG_arg_fail(1)) SWIG_fail;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (int)(arg1)->GetRudderPosition();
11787
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 {
11792 resultobj = SWIG_From_int((int)(result));
11793 }
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11801 PyObject *resultobj;
11802 wxJoystick *arg1 = (wxJoystick *) 0 ;
11803 int result;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "self", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11811 if (SWIG_arg_fail(1)) SWIG_fail;
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (int)(arg1)->GetUPosition();
11815
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 {
11820 resultobj = SWIG_From_int((int)(result));
11821 }
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11829 PyObject *resultobj;
11830 wxJoystick *arg1 = (wxJoystick *) 0 ;
11831 int result;
11832 PyObject * obj0 = 0 ;
11833 char *kwnames[] = {
11834 (char *) "self", NULL
11835 };
11836
11837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11839 if (SWIG_arg_fail(1)) SWIG_fail;
11840 {
11841 PyThreadState* __tstate = wxPyBeginAllowThreads();
11842 result = (int)(arg1)->GetVPosition();
11843
11844 wxPyEndAllowThreads(__tstate);
11845 if (PyErr_Occurred()) SWIG_fail;
11846 }
11847 {
11848 resultobj = SWIG_From_int((int)(result));
11849 }
11850 return resultobj;
11851 fail:
11852 return NULL;
11853 }
11854
11855
11856 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11857 PyObject *resultobj;
11858 wxJoystick *arg1 = (wxJoystick *) 0 ;
11859 int result;
11860 PyObject * obj0 = 0 ;
11861 char *kwnames[] = {
11862 (char *) "self", NULL
11863 };
11864
11865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11867 if (SWIG_arg_fail(1)) SWIG_fail;
11868 {
11869 PyThreadState* __tstate = wxPyBeginAllowThreads();
11870 result = (int)(arg1)->GetMovementThreshold();
11871
11872 wxPyEndAllowThreads(__tstate);
11873 if (PyErr_Occurred()) SWIG_fail;
11874 }
11875 {
11876 resultobj = SWIG_From_int((int)(result));
11877 }
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11885 PyObject *resultobj;
11886 wxJoystick *arg1 = (wxJoystick *) 0 ;
11887 int arg2 ;
11888 PyObject * obj0 = 0 ;
11889 PyObject * obj1 = 0 ;
11890 char *kwnames[] = {
11891 (char *) "self",(char *) "threshold", NULL
11892 };
11893
11894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11896 if (SWIG_arg_fail(1)) SWIG_fail;
11897 {
11898 arg2 = (int)(SWIG_As_int(obj1));
11899 if (SWIG_arg_fail(2)) SWIG_fail;
11900 }
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 (arg1)->SetMovementThreshold(arg2);
11904
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 Py_INCREF(Py_None); resultobj = Py_None;
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj;
11917 wxJoystick *arg1 = (wxJoystick *) 0 ;
11918 bool result;
11919 PyObject * obj0 = 0 ;
11920 char *kwnames[] = {
11921 (char *) "self", NULL
11922 };
11923
11924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11926 if (SWIG_arg_fail(1)) SWIG_fail;
11927 {
11928 PyThreadState* __tstate = wxPyBeginAllowThreads();
11929 result = (bool)(arg1)->IsOk();
11930
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 {
11935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11936 }
11937 return resultobj;
11938 fail:
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxJoystick *arg1 = (wxJoystick *) 0 ;
11946 int result;
11947 PyObject * obj0 = 0 ;
11948 char *kwnames[] = {
11949 (char *) "self", NULL
11950 };
11951
11952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11954 if (SWIG_arg_fail(1)) SWIG_fail;
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (int)(arg1)->GetNumberJoysticks();
11958
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = SWIG_From_int((int)(result));
11964 }
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj;
11973 wxJoystick *arg1 = (wxJoystick *) 0 ;
11974 int result;
11975 PyObject * obj0 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (int)(arg1)->GetManufacturerId();
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 resultobj = SWIG_From_int((int)(result));
11992 }
11993 return resultobj;
11994 fail:
11995 return NULL;
11996 }
11997
11998
11999 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
12000 PyObject *resultobj;
12001 wxJoystick *arg1 = (wxJoystick *) 0 ;
12002 int result;
12003 PyObject * obj0 = 0 ;
12004 char *kwnames[] = {
12005 (char *) "self", NULL
12006 };
12007
12008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
12009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12010 if (SWIG_arg_fail(1)) SWIG_fail;
12011 {
12012 PyThreadState* __tstate = wxPyBeginAllowThreads();
12013 result = (int)(arg1)->GetProductId();
12014
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 {
12019 resultobj = SWIG_From_int((int)(result));
12020 }
12021 return resultobj;
12022 fail:
12023 return NULL;
12024 }
12025
12026
12027 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
12028 PyObject *resultobj;
12029 wxJoystick *arg1 = (wxJoystick *) 0 ;
12030 wxString result;
12031 PyObject * obj0 = 0 ;
12032 char *kwnames[] = {
12033 (char *) "self", NULL
12034 };
12035
12036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
12037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12038 if (SWIG_arg_fail(1)) SWIG_fail;
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 result = (arg1)->GetProductName();
12042
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 {
12047 #if wxUSE_UNICODE
12048 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12049 #else
12050 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12051 #endif
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 int result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (int)(arg1)->GetXMin();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 resultobj = SWIG_From_int((int)(result));
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxJoystick *arg1 = (wxJoystick *) 0 ;
12090 int result;
12091 PyObject * obj0 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = (int)(arg1)->GetYMin();
12102
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 resultobj = SWIG_From_int((int)(result));
12108 }
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12116 PyObject *resultobj;
12117 wxJoystick *arg1 = (wxJoystick *) 0 ;
12118 int result;
12119 PyObject * obj0 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 PyThreadState* __tstate = wxPyBeginAllowThreads();
12129 result = (int)(arg1)->GetZMin();
12130
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 {
12135 resultobj = SWIG_From_int((int)(result));
12136 }
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj;
12145 wxJoystick *arg1 = (wxJoystick *) 0 ;
12146 int result;
12147 PyObject * obj0 = 0 ;
12148 char *kwnames[] = {
12149 (char *) "self", NULL
12150 };
12151
12152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12154 if (SWIG_arg_fail(1)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (int)(arg1)->GetXMax();
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 {
12163 resultobj = SWIG_From_int((int)(result));
12164 }
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj;
12173 wxJoystick *arg1 = (wxJoystick *) 0 ;
12174 int result;
12175 PyObject * obj0 = 0 ;
12176 char *kwnames[] = {
12177 (char *) "self", NULL
12178 };
12179
12180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12182 if (SWIG_arg_fail(1)) SWIG_fail;
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (int)(arg1)->GetYMax();
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 resultobj = SWIG_From_int((int)(result));
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj;
12201 wxJoystick *arg1 = (wxJoystick *) 0 ;
12202 int result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (int)(arg1)->GetZMax();
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = SWIG_From_int((int)(result));
12220 }
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxJoystick *arg1 = (wxJoystick *) 0 ;
12230 int result;
12231 PyObject * obj0 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (int)(arg1)->GetNumberButtons();
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = SWIG_From_int((int)(result));
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxJoystick *arg1 = (wxJoystick *) 0 ;
12258 int result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (int)(arg1)->GetNumberAxes();
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = SWIG_From_int((int)(result));
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxJoystick *arg1 = (wxJoystick *) 0 ;
12286 int result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12294 if (SWIG_arg_fail(1)) SWIG_fail;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (int)(arg1)->GetMaxButtons();
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = SWIG_From_int((int)(result));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxJoystick *arg1 = (wxJoystick *) 0 ;
12314 int result;
12315 PyObject * obj0 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (int)(arg1)->GetMaxAxes();
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = SWIG_From_int((int)(result));
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxJoystick *arg1 = (wxJoystick *) 0 ;
12342 int result;
12343 PyObject * obj0 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "self", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12350 if (SWIG_arg_fail(1)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (int)(arg1)->GetPollingMin();
12354
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 resultobj = SWIG_From_int((int)(result));
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj;
12369 wxJoystick *arg1 = (wxJoystick *) 0 ;
12370 int result;
12371 PyObject * obj0 = 0 ;
12372 char *kwnames[] = {
12373 (char *) "self", NULL
12374 };
12375
12376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12378 if (SWIG_arg_fail(1)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (int)(arg1)->GetPollingMax();
12382
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 resultobj = SWIG_From_int((int)(result));
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj;
12397 wxJoystick *arg1 = (wxJoystick *) 0 ;
12398 int result;
12399 PyObject * obj0 = 0 ;
12400 char *kwnames[] = {
12401 (char *) "self", NULL
12402 };
12403
12404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12406 if (SWIG_arg_fail(1)) SWIG_fail;
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (int)(arg1)->GetRudderMin();
12410
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 resultobj = SWIG_From_int((int)(result));
12416 }
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj;
12425 wxJoystick *arg1 = (wxJoystick *) 0 ;
12426 int result;
12427 PyObject * obj0 = 0 ;
12428 char *kwnames[] = {
12429 (char *) "self", NULL
12430 };
12431
12432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12434 if (SWIG_arg_fail(1)) SWIG_fail;
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 result = (int)(arg1)->GetRudderMax();
12438
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 {
12443 resultobj = SWIG_From_int((int)(result));
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxJoystick *arg1 = (wxJoystick *) 0 ;
12454 int result;
12455 PyObject * obj0 = 0 ;
12456 char *kwnames[] = {
12457 (char *) "self", NULL
12458 };
12459
12460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12462 if (SWIG_arg_fail(1)) SWIG_fail;
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (int)(arg1)->GetUMin();
12466
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 {
12471 resultobj = SWIG_From_int((int)(result));
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj;
12481 wxJoystick *arg1 = (wxJoystick *) 0 ;
12482 int result;
12483 PyObject * obj0 = 0 ;
12484 char *kwnames[] = {
12485 (char *) "self", NULL
12486 };
12487
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 result = (int)(arg1)->GetUMax();
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 {
12499 resultobj = SWIG_From_int((int)(result));
12500 }
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj;
12509 wxJoystick *arg1 = (wxJoystick *) 0 ;
12510 int result;
12511 PyObject * obj0 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (int)(arg1)->GetVMin();
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 resultobj = SWIG_From_int((int)(result));
12528 }
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj;
12537 wxJoystick *arg1 = (wxJoystick *) 0 ;
12538 int result;
12539 PyObject * obj0 = 0 ;
12540 char *kwnames[] = {
12541 (char *) "self", NULL
12542 };
12543
12544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12546 if (SWIG_arg_fail(1)) SWIG_fail;
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (int)(arg1)->GetVMax();
12550
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 {
12555 resultobj = SWIG_From_int((int)(result));
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj;
12565 wxJoystick *arg1 = (wxJoystick *) 0 ;
12566 bool result;
12567 PyObject * obj0 = 0 ;
12568 char *kwnames[] = {
12569 (char *) "self", NULL
12570 };
12571
12572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12574 if (SWIG_arg_fail(1)) SWIG_fail;
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 result = (bool)(arg1)->HasRudder();
12578
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 {
12583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12584 }
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj;
12593 wxJoystick *arg1 = (wxJoystick *) 0 ;
12594 bool result;
12595 PyObject * obj0 = 0 ;
12596 char *kwnames[] = {
12597 (char *) "self", NULL
12598 };
12599
12600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12602 if (SWIG_arg_fail(1)) SWIG_fail;
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (bool)(arg1)->HasZ();
12606
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 {
12611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12612 }
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj;
12621 wxJoystick *arg1 = (wxJoystick *) 0 ;
12622 bool result;
12623 PyObject * obj0 = 0 ;
12624 char *kwnames[] = {
12625 (char *) "self", NULL
12626 };
12627
12628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12630 if (SWIG_arg_fail(1)) SWIG_fail;
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->HasU();
12634
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj;
12649 wxJoystick *arg1 = (wxJoystick *) 0 ;
12650 bool result;
12651 PyObject * obj0 = 0 ;
12652 char *kwnames[] = {
12653 (char *) "self", NULL
12654 };
12655
12656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(1)) SWIG_fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (bool)(arg1)->HasV();
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 {
12667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12668 }
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj;
12677 wxJoystick *arg1 = (wxJoystick *) 0 ;
12678 bool result;
12679 PyObject * obj0 = 0 ;
12680 char *kwnames[] = {
12681 (char *) "self", NULL
12682 };
12683
12684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12686 if (SWIG_arg_fail(1)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (bool)(arg1)->HasPOV();
12690
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxJoystick *arg1 = (wxJoystick *) 0 ;
12706 bool result;
12707 PyObject * obj0 = 0 ;
12708 char *kwnames[] = {
12709 (char *) "self", NULL
12710 };
12711
12712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12714 if (SWIG_arg_fail(1)) SWIG_fail;
12715 {
12716 PyThreadState* __tstate = wxPyBeginAllowThreads();
12717 result = (bool)(arg1)->HasPOV4Dir();
12718
12719 wxPyEndAllowThreads(__tstate);
12720 if (PyErr_Occurred()) SWIG_fail;
12721 }
12722 {
12723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12724 }
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12732 PyObject *resultobj;
12733 wxJoystick *arg1 = (wxJoystick *) 0 ;
12734 bool result;
12735 PyObject * obj0 = 0 ;
12736 char *kwnames[] = {
12737 (char *) "self", NULL
12738 };
12739
12740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12742 if (SWIG_arg_fail(1)) SWIG_fail;
12743 {
12744 PyThreadState* __tstate = wxPyBeginAllowThreads();
12745 result = (bool)(arg1)->HasPOVCTS();
12746
12747 wxPyEndAllowThreads(__tstate);
12748 if (PyErr_Occurred()) SWIG_fail;
12749 }
12750 {
12751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12752 }
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj;
12761 wxJoystick *arg1 = (wxJoystick *) 0 ;
12762 wxWindow *arg2 = (wxWindow *) 0 ;
12763 int arg3 = (int) 0 ;
12764 bool result;
12765 PyObject * obj0 = 0 ;
12766 PyObject * obj1 = 0 ;
12767 PyObject * obj2 = 0 ;
12768 char *kwnames[] = {
12769 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12770 };
12771
12772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12774 if (SWIG_arg_fail(1)) SWIG_fail;
12775 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(2)) SWIG_fail;
12777 if (obj2) {
12778 {
12779 arg3 = (int)(SWIG_As_int(obj2));
12780 if (SWIG_arg_fail(3)) SWIG_fail;
12781 }
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (bool)(arg1)->SetCapture(arg2,arg3);
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_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12800 PyObject *resultobj;
12801 wxJoystick *arg1 = (wxJoystick *) 0 ;
12802 bool result;
12803 PyObject * obj0 = 0 ;
12804 char *kwnames[] = {
12805 (char *) "self", NULL
12806 };
12807
12808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12810 if (SWIG_arg_fail(1)) SWIG_fail;
12811 {
12812 PyThreadState* __tstate = wxPyBeginAllowThreads();
12813 result = (bool)(arg1)->ReleaseCapture();
12814
12815 wxPyEndAllowThreads(__tstate);
12816 if (PyErr_Occurred()) SWIG_fail;
12817 }
12818 {
12819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12820 }
12821 return resultobj;
12822 fail:
12823 return NULL;
12824 }
12825
12826
12827 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12828 PyObject *obj;
12829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12830 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12831 Py_INCREF(obj);
12832 return Py_BuildValue((char *)"");
12833 }
12834 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12835 PyObject *resultobj;
12836 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12837 int arg2 = (int) 0 ;
12838 int arg3 = (int) wxJOYSTICK1 ;
12839 int arg4 = (int) 0 ;
12840 wxJoystickEvent *result;
12841 PyObject * obj0 = 0 ;
12842 PyObject * obj1 = 0 ;
12843 PyObject * obj2 = 0 ;
12844 PyObject * obj3 = 0 ;
12845 char *kwnames[] = {
12846 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12847 };
12848
12849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12850 if (obj0) {
12851 {
12852 arg1 = (wxEventType)(SWIG_As_int(obj0));
12853 if (SWIG_arg_fail(1)) SWIG_fail;
12854 }
12855 }
12856 if (obj1) {
12857 {
12858 arg2 = (int)(SWIG_As_int(obj1));
12859 if (SWIG_arg_fail(2)) SWIG_fail;
12860 }
12861 }
12862 if (obj2) {
12863 {
12864 arg3 = (int)(SWIG_As_int(obj2));
12865 if (SWIG_arg_fail(3)) SWIG_fail;
12866 }
12867 }
12868 if (obj3) {
12869 {
12870 arg4 = (int)(SWIG_As_int(obj3));
12871 if (SWIG_arg_fail(4)) SWIG_fail;
12872 }
12873 }
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12877
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12882 return resultobj;
12883 fail:
12884 return NULL;
12885 }
12886
12887
12888 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12889 PyObject *resultobj;
12890 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12891 wxPoint result;
12892 PyObject * obj0 = 0 ;
12893 char *kwnames[] = {
12894 (char *) "self", NULL
12895 };
12896
12897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12899 if (SWIG_arg_fail(1)) SWIG_fail;
12900 {
12901 PyThreadState* __tstate = wxPyBeginAllowThreads();
12902 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12903
12904 wxPyEndAllowThreads(__tstate);
12905 if (PyErr_Occurred()) SWIG_fail;
12906 }
12907 {
12908 wxPoint * resultptr;
12909 resultptr = new wxPoint((wxPoint &)(result));
12910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12911 }
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12921 int result;
12922 PyObject * obj0 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 {
12938 resultobj = SWIG_From_int((int)(result));
12939 }
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj;
12948 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12949 int result;
12950 PyObject * obj0 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12961
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 {
12966 resultobj = SWIG_From_int((int)(result));
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12977 int result;
12978 PyObject * obj0 = 0 ;
12979 char *kwnames[] = {
12980 (char *) "self", NULL
12981 };
12982
12983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12985 if (SWIG_arg_fail(1)) SWIG_fail;
12986 {
12987 PyThreadState* __tstate = wxPyBeginAllowThreads();
12988 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12989
12990 wxPyEndAllowThreads(__tstate);
12991 if (PyErr_Occurred()) SWIG_fail;
12992 }
12993 {
12994 resultobj = SWIG_From_int((int)(result));
12995 }
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13003 PyObject *resultobj;
13004 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13005 int result;
13006 PyObject * obj0 = 0 ;
13007 char *kwnames[] = {
13008 (char *) "self", NULL
13009 };
13010
13011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
13012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13013 if (SWIG_arg_fail(1)) SWIG_fail;
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
13017
13018 wxPyEndAllowThreads(__tstate);
13019 if (PyErr_Occurred()) SWIG_fail;
13020 }
13021 {
13022 resultobj = SWIG_From_int((int)(result));
13023 }
13024 return resultobj;
13025 fail:
13026 return NULL;
13027 }
13028
13029
13030 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
13031 PyObject *resultobj;
13032 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13033 int arg2 ;
13034 PyObject * obj0 = 0 ;
13035 PyObject * obj1 = 0 ;
13036 char *kwnames[] = {
13037 (char *) "self",(char *) "stick", NULL
13038 };
13039
13040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
13041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13042 if (SWIG_arg_fail(1)) SWIG_fail;
13043 {
13044 arg2 = (int)(SWIG_As_int(obj1));
13045 if (SWIG_arg_fail(2)) SWIG_fail;
13046 }
13047 {
13048 PyThreadState* __tstate = wxPyBeginAllowThreads();
13049 (arg1)->SetJoystick(arg2);
13050
13051 wxPyEndAllowThreads(__tstate);
13052 if (PyErr_Occurred()) SWIG_fail;
13053 }
13054 Py_INCREF(Py_None); resultobj = Py_None;
13055 return resultobj;
13056 fail:
13057 return NULL;
13058 }
13059
13060
13061 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj;
13063 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13064 int arg2 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 char *kwnames[] = {
13068 (char *) "self",(char *) "state", NULL
13069 };
13070
13071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13073 if (SWIG_arg_fail(1)) SWIG_fail;
13074 {
13075 arg2 = (int)(SWIG_As_int(obj1));
13076 if (SWIG_arg_fail(2)) SWIG_fail;
13077 }
13078 {
13079 PyThreadState* __tstate = wxPyBeginAllowThreads();
13080 (arg1)->SetButtonState(arg2);
13081
13082 wxPyEndAllowThreads(__tstate);
13083 if (PyErr_Occurred()) SWIG_fail;
13084 }
13085 Py_INCREF(Py_None); resultobj = Py_None;
13086 return resultobj;
13087 fail:
13088 return NULL;
13089 }
13090
13091
13092 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13093 PyObject *resultobj;
13094 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13095 int arg2 ;
13096 PyObject * obj0 = 0 ;
13097 PyObject * obj1 = 0 ;
13098 char *kwnames[] = {
13099 (char *) "self",(char *) "change", NULL
13100 };
13101
13102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13104 if (SWIG_arg_fail(1)) SWIG_fail;
13105 {
13106 arg2 = (int)(SWIG_As_int(obj1));
13107 if (SWIG_arg_fail(2)) SWIG_fail;
13108 }
13109 {
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 (arg1)->SetButtonChange(arg2);
13112
13113 wxPyEndAllowThreads(__tstate);
13114 if (PyErr_Occurred()) SWIG_fail;
13115 }
13116 Py_INCREF(Py_None); resultobj = Py_None;
13117 return resultobj;
13118 fail:
13119 return NULL;
13120 }
13121
13122
13123 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13124 PyObject *resultobj;
13125 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13126 wxPoint *arg2 = 0 ;
13127 wxPoint temp2 ;
13128 PyObject * obj0 = 0 ;
13129 PyObject * obj1 = 0 ;
13130 char *kwnames[] = {
13131 (char *) "self",(char *) "pos", NULL
13132 };
13133
13134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13136 if (SWIG_arg_fail(1)) SWIG_fail;
13137 {
13138 arg2 = &temp2;
13139 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13140 }
13141 {
13142 PyThreadState* __tstate = wxPyBeginAllowThreads();
13143 (arg1)->SetPosition((wxPoint const &)*arg2);
13144
13145 wxPyEndAllowThreads(__tstate);
13146 if (PyErr_Occurred()) SWIG_fail;
13147 }
13148 Py_INCREF(Py_None); resultobj = Py_None;
13149 return resultobj;
13150 fail:
13151 return NULL;
13152 }
13153
13154
13155 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13156 PyObject *resultobj;
13157 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13158 int arg2 ;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 char *kwnames[] = {
13162 (char *) "self",(char *) "zPos", NULL
13163 };
13164
13165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13167 if (SWIG_arg_fail(1)) SWIG_fail;
13168 {
13169 arg2 = (int)(SWIG_As_int(obj1));
13170 if (SWIG_arg_fail(2)) SWIG_fail;
13171 }
13172 {
13173 PyThreadState* __tstate = wxPyBeginAllowThreads();
13174 (arg1)->SetZPosition(arg2);
13175
13176 wxPyEndAllowThreads(__tstate);
13177 if (PyErr_Occurred()) SWIG_fail;
13178 }
13179 Py_INCREF(Py_None); resultobj = Py_None;
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13189 bool result;
13190 PyObject * obj0 = 0 ;
13191 char *kwnames[] = {
13192 (char *) "self", NULL
13193 };
13194
13195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13197 if (SWIG_arg_fail(1)) SWIG_fail;
13198 {
13199 PyThreadState* __tstate = wxPyBeginAllowThreads();
13200 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13201
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj;
13216 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13217 bool result;
13218 PyObject * obj0 = 0 ;
13219 char *kwnames[] = {
13220 (char *) "self", NULL
13221 };
13222
13223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13225 if (SWIG_arg_fail(1)) SWIG_fail;
13226 {
13227 PyThreadState* __tstate = wxPyBeginAllowThreads();
13228 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13229
13230 wxPyEndAllowThreads(__tstate);
13231 if (PyErr_Occurred()) SWIG_fail;
13232 }
13233 {
13234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13235 }
13236 return resultobj;
13237 fail:
13238 return NULL;
13239 }
13240
13241
13242 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj;
13244 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13245 bool result;
13246 PyObject * obj0 = 0 ;
13247 char *kwnames[] = {
13248 (char *) "self", NULL
13249 };
13250
13251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13253 if (SWIG_arg_fail(1)) SWIG_fail;
13254 {
13255 PyThreadState* __tstate = wxPyBeginAllowThreads();
13256 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13257
13258 wxPyEndAllowThreads(__tstate);
13259 if (PyErr_Occurred()) SWIG_fail;
13260 }
13261 {
13262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13263 }
13264 return resultobj;
13265 fail:
13266 return NULL;
13267 }
13268
13269
13270 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13271 PyObject *resultobj;
13272 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13273 int arg2 = (int) wxJOY_BUTTON_ANY ;
13274 bool result;
13275 PyObject * obj0 = 0 ;
13276 PyObject * obj1 = 0 ;
13277 char *kwnames[] = {
13278 (char *) "self",(char *) "but", NULL
13279 };
13280
13281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13283 if (SWIG_arg_fail(1)) SWIG_fail;
13284 if (obj1) {
13285 {
13286 arg2 = (int)(SWIG_As_int(obj1));
13287 if (SWIG_arg_fail(2)) SWIG_fail;
13288 }
13289 }
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13293
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 {
13298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13299 }
13300 return resultobj;
13301 fail:
13302 return NULL;
13303 }
13304
13305
13306 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13307 PyObject *resultobj;
13308 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13309 int arg2 = (int) wxJOY_BUTTON_ANY ;
13310 bool result;
13311 PyObject * obj0 = 0 ;
13312 PyObject * obj1 = 0 ;
13313 char *kwnames[] = {
13314 (char *) "self",(char *) "but", NULL
13315 };
13316
13317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13319 if (SWIG_arg_fail(1)) SWIG_fail;
13320 if (obj1) {
13321 {
13322 arg2 = (int)(SWIG_As_int(obj1));
13323 if (SWIG_arg_fail(2)) SWIG_fail;
13324 }
13325 }
13326 {
13327 PyThreadState* __tstate = wxPyBeginAllowThreads();
13328 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13329
13330 wxPyEndAllowThreads(__tstate);
13331 if (PyErr_Occurred()) SWIG_fail;
13332 }
13333 {
13334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13335 }
13336 return resultobj;
13337 fail:
13338 return NULL;
13339 }
13340
13341
13342 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13343 PyObject *resultobj;
13344 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13345 int arg2 = (int) wxJOY_BUTTON_ANY ;
13346 bool result;
13347 PyObject * obj0 = 0 ;
13348 PyObject * obj1 = 0 ;
13349 char *kwnames[] = {
13350 (char *) "self",(char *) "but", NULL
13351 };
13352
13353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13355 if (SWIG_arg_fail(1)) SWIG_fail;
13356 if (obj1) {
13357 {
13358 arg2 = (int)(SWIG_As_int(obj1));
13359 if (SWIG_arg_fail(2)) SWIG_fail;
13360 }
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 {
13370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13371 }
13372 return resultobj;
13373 fail:
13374 return NULL;
13375 }
13376
13377
13378 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13379 PyObject *obj;
13380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13381 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13382 Py_INCREF(obj);
13383 return Py_BuildValue((char *)"");
13384 }
13385 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13386 PyObject *resultobj;
13387 wxString const &arg1_defvalue = wxPyEmptyString ;
13388 wxString *arg1 = (wxString *) &arg1_defvalue ;
13389 wxSound *result;
13390 bool temp1 = false ;
13391 PyObject * obj0 = 0 ;
13392 char *kwnames[] = {
13393 (char *) "fileName", NULL
13394 };
13395
13396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13397 if (obj0) {
13398 {
13399 arg1 = wxString_in_helper(obj0);
13400 if (arg1 == NULL) SWIG_fail;
13401 temp1 = true;
13402 }
13403 }
13404 {
13405 if (!wxPyCheckForApp()) SWIG_fail;
13406 PyThreadState* __tstate = wxPyBeginAllowThreads();
13407 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13408
13409 wxPyEndAllowThreads(__tstate);
13410 if (PyErr_Occurred()) SWIG_fail;
13411 }
13412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13413 {
13414 if (temp1)
13415 delete arg1;
13416 }
13417 return resultobj;
13418 fail:
13419 {
13420 if (temp1)
13421 delete arg1;
13422 }
13423 return NULL;
13424 }
13425
13426
13427 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13428 PyObject *resultobj;
13429 PyObject *arg1 = (PyObject *) 0 ;
13430 wxSound *result;
13431 PyObject * obj0 = 0 ;
13432 char *kwnames[] = {
13433 (char *) "data", NULL
13434 };
13435
13436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13437 arg1 = obj0;
13438 {
13439 if (!wxPyCheckForApp()) SWIG_fail;
13440 PyThreadState* __tstate = wxPyBeginAllowThreads();
13441 result = (wxSound *)new_wxSound(arg1);
13442
13443 wxPyEndAllowThreads(__tstate);
13444 if (PyErr_Occurred()) SWIG_fail;
13445 }
13446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13447 return resultobj;
13448 fail:
13449 return NULL;
13450 }
13451
13452
13453 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj;
13455 wxSound *arg1 = (wxSound *) 0 ;
13456 PyObject * obj0 = 0 ;
13457 char *kwnames[] = {
13458 (char *) "self", NULL
13459 };
13460
13461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13463 if (SWIG_arg_fail(1)) SWIG_fail;
13464 {
13465 PyThreadState* __tstate = wxPyBeginAllowThreads();
13466 delete arg1;
13467
13468 wxPyEndAllowThreads(__tstate);
13469 if (PyErr_Occurred()) SWIG_fail;
13470 }
13471 Py_INCREF(Py_None); resultobj = Py_None;
13472 return resultobj;
13473 fail:
13474 return NULL;
13475 }
13476
13477
13478 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13479 PyObject *resultobj;
13480 wxSound *arg1 = (wxSound *) 0 ;
13481 wxString *arg2 = 0 ;
13482 bool result;
13483 bool temp2 = false ;
13484 PyObject * obj0 = 0 ;
13485 PyObject * obj1 = 0 ;
13486 char *kwnames[] = {
13487 (char *) "self",(char *) "fileName", NULL
13488 };
13489
13490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13492 if (SWIG_arg_fail(1)) SWIG_fail;
13493 {
13494 arg2 = wxString_in_helper(obj1);
13495 if (arg2 == NULL) SWIG_fail;
13496 temp2 = true;
13497 }
13498 {
13499 PyThreadState* __tstate = wxPyBeginAllowThreads();
13500 result = (bool)(arg1)->Create((wxString const &)*arg2);
13501
13502 wxPyEndAllowThreads(__tstate);
13503 if (PyErr_Occurred()) SWIG_fail;
13504 }
13505 {
13506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13507 }
13508 {
13509 if (temp2)
13510 delete arg2;
13511 }
13512 return resultobj;
13513 fail:
13514 {
13515 if (temp2)
13516 delete arg2;
13517 }
13518 return NULL;
13519 }
13520
13521
13522 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13523 PyObject *resultobj;
13524 wxSound *arg1 = (wxSound *) 0 ;
13525 PyObject *arg2 = (PyObject *) 0 ;
13526 bool result;
13527 PyObject * obj0 = 0 ;
13528 PyObject * obj1 = 0 ;
13529 char *kwnames[] = {
13530 (char *) "self",(char *) "data", NULL
13531 };
13532
13533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13535 if (SWIG_arg_fail(1)) SWIG_fail;
13536 arg2 = obj1;
13537 {
13538 PyThreadState* __tstate = wxPyBeginAllowThreads();
13539 result = (bool)wxSound_CreateFromData(arg1,arg2);
13540
13541 wxPyEndAllowThreads(__tstate);
13542 if (PyErr_Occurred()) SWIG_fail;
13543 }
13544 {
13545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13546 }
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj;
13555 wxSound *arg1 = (wxSound *) 0 ;
13556 bool result;
13557 PyObject * obj0 = 0 ;
13558 char *kwnames[] = {
13559 (char *) "self", NULL
13560 };
13561
13562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13564 if (SWIG_arg_fail(1)) SWIG_fail;
13565 {
13566 PyThreadState* __tstate = wxPyBeginAllowThreads();
13567 result = (bool)(arg1)->IsOk();
13568
13569 wxPyEndAllowThreads(__tstate);
13570 if (PyErr_Occurred()) SWIG_fail;
13571 }
13572 {
13573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13574 }
13575 return resultobj;
13576 fail:
13577 return NULL;
13578 }
13579
13580
13581 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13582 PyObject *resultobj;
13583 wxSound *arg1 = (wxSound *) 0 ;
13584 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13585 bool result;
13586 PyObject * obj0 = 0 ;
13587 PyObject * obj1 = 0 ;
13588 char *kwnames[] = {
13589 (char *) "self",(char *) "flags", NULL
13590 };
13591
13592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13594 if (SWIG_arg_fail(1)) SWIG_fail;
13595 if (obj1) {
13596 {
13597 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13598 if (SWIG_arg_fail(2)) SWIG_fail;
13599 }
13600 }
13601 {
13602 if (!wxPyCheckForApp()) SWIG_fail;
13603 PyThreadState* __tstate = wxPyBeginAllowThreads();
13604 result = (bool)((wxSound const *)arg1)->Play(arg2);
13605
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 {
13610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13611 }
13612 return resultobj;
13613 fail:
13614 return NULL;
13615 }
13616
13617
13618 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13619 PyObject *resultobj;
13620 wxString *arg1 = 0 ;
13621 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13622 bool result;
13623 bool temp1 = false ;
13624 PyObject * obj0 = 0 ;
13625 PyObject * obj1 = 0 ;
13626 char *kwnames[] = {
13627 (char *) "filename",(char *) "flags", NULL
13628 };
13629
13630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13631 {
13632 arg1 = wxString_in_helper(obj0);
13633 if (arg1 == NULL) SWIG_fail;
13634 temp1 = true;
13635 }
13636 if (obj1) {
13637 {
13638 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13639 if (SWIG_arg_fail(2)) SWIG_fail;
13640 }
13641 }
13642 {
13643 if (!wxPyCheckForApp()) SWIG_fail;
13644 PyThreadState* __tstate = wxPyBeginAllowThreads();
13645 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13646
13647 wxPyEndAllowThreads(__tstate);
13648 if (PyErr_Occurred()) SWIG_fail;
13649 }
13650 {
13651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13652 }
13653 {
13654 if (temp1)
13655 delete arg1;
13656 }
13657 return resultobj;
13658 fail:
13659 {
13660 if (temp1)
13661 delete arg1;
13662 }
13663 return NULL;
13664 }
13665
13666
13667 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj;
13669 char *kwnames[] = {
13670 NULL
13671 };
13672
13673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13674 {
13675 if (!wxPyCheckForApp()) SWIG_fail;
13676 PyThreadState* __tstate = wxPyBeginAllowThreads();
13677 wxSound::Stop();
13678
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 Py_INCREF(Py_None); resultobj = Py_None;
13683 return resultobj;
13684 fail:
13685 return NULL;
13686 }
13687
13688
13689 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13690 PyObject *obj;
13691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13692 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13693 Py_INCREF(obj);
13694 return Py_BuildValue((char *)"");
13695 }
13696 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13697 PyObject *resultobj;
13698 wxString *arg1 = 0 ;
13699 wxString *arg2 = 0 ;
13700 wxString *arg3 = 0 ;
13701 wxString *arg4 = 0 ;
13702 wxFileTypeInfo *result;
13703 bool temp1 = false ;
13704 bool temp2 = false ;
13705 bool temp3 = false ;
13706 bool temp4 = false ;
13707 PyObject * obj0 = 0 ;
13708 PyObject * obj1 = 0 ;
13709 PyObject * obj2 = 0 ;
13710 PyObject * obj3 = 0 ;
13711 char *kwnames[] = {
13712 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13713 };
13714
13715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13716 {
13717 arg1 = wxString_in_helper(obj0);
13718 if (arg1 == NULL) SWIG_fail;
13719 temp1 = true;
13720 }
13721 {
13722 arg2 = wxString_in_helper(obj1);
13723 if (arg2 == NULL) SWIG_fail;
13724 temp2 = true;
13725 }
13726 {
13727 arg3 = wxString_in_helper(obj2);
13728 if (arg3 == NULL) SWIG_fail;
13729 temp3 = true;
13730 }
13731 {
13732 arg4 = wxString_in_helper(obj3);
13733 if (arg4 == NULL) SWIG_fail;
13734 temp4 = true;
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13739
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13744 {
13745 if (temp1)
13746 delete arg1;
13747 }
13748 {
13749 if (temp2)
13750 delete arg2;
13751 }
13752 {
13753 if (temp3)
13754 delete arg3;
13755 }
13756 {
13757 if (temp4)
13758 delete arg4;
13759 }
13760 return resultobj;
13761 fail:
13762 {
13763 if (temp1)
13764 delete arg1;
13765 }
13766 {
13767 if (temp2)
13768 delete arg2;
13769 }
13770 {
13771 if (temp3)
13772 delete arg3;
13773 }
13774 {
13775 if (temp4)
13776 delete arg4;
13777 }
13778 return NULL;
13779 }
13780
13781
13782 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj;
13784 wxArrayString *arg1 = 0 ;
13785 wxFileTypeInfo *result;
13786 bool temp1 = false ;
13787 PyObject * obj0 = 0 ;
13788 char *kwnames[] = {
13789 (char *) "sArray", NULL
13790 };
13791
13792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13793 {
13794 if (! PySequence_Check(obj0)) {
13795 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13796 SWIG_fail;
13797 }
13798 arg1 = new wxArrayString;
13799 temp1 = true;
13800 int i, len=PySequence_Length(obj0);
13801 for (i=0; i<len; i++) {
13802 PyObject* item = PySequence_GetItem(obj0, i);
13803 #if wxUSE_UNICODE
13804 PyObject* str = PyObject_Unicode(item);
13805 #else
13806 PyObject* str = PyObject_Str(item);
13807 #endif
13808 if (PyErr_Occurred()) SWIG_fail;
13809 arg1->Add(Py2wxString(str));
13810 Py_DECREF(item);
13811 Py_DECREF(str);
13812 }
13813 }
13814 {
13815 PyThreadState* __tstate = wxPyBeginAllowThreads();
13816 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13817
13818 wxPyEndAllowThreads(__tstate);
13819 if (PyErr_Occurred()) SWIG_fail;
13820 }
13821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13822 {
13823 if (temp1) delete arg1;
13824 }
13825 return resultobj;
13826 fail:
13827 {
13828 if (temp1) delete arg1;
13829 }
13830 return NULL;
13831 }
13832
13833
13834 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj;
13836 wxFileTypeInfo *result;
13837 char *kwnames[] = {
13838 NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13845
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj;
13858 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13859 bool result;
13860 PyObject * obj0 = 0 ;
13861 char *kwnames[] = {
13862 (char *) "self", NULL
13863 };
13864
13865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13867 if (SWIG_arg_fail(1)) SWIG_fail;
13868 {
13869 PyThreadState* __tstate = wxPyBeginAllowThreads();
13870 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13871
13872 wxPyEndAllowThreads(__tstate);
13873 if (PyErr_Occurred()) SWIG_fail;
13874 }
13875 {
13876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13877 }
13878 return resultobj;
13879 fail:
13880 return NULL;
13881 }
13882
13883
13884 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13885 PyObject *resultobj;
13886 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13887 wxString *arg2 = 0 ;
13888 int arg3 = (int) 0 ;
13889 bool temp2 = false ;
13890 PyObject * obj0 = 0 ;
13891 PyObject * obj1 = 0 ;
13892 PyObject * obj2 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 arg2 = wxString_in_helper(obj1);
13902 if (arg2 == NULL) SWIG_fail;
13903 temp2 = true;
13904 }
13905 if (obj2) {
13906 {
13907 arg3 = (int)(SWIG_As_int(obj2));
13908 if (SWIG_arg_fail(3)) SWIG_fail;
13909 }
13910 }
13911 {
13912 PyThreadState* __tstate = wxPyBeginAllowThreads();
13913 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13914
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 Py_INCREF(Py_None); resultobj = Py_None;
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return resultobj;
13924 fail:
13925 {
13926 if (temp2)
13927 delete arg2;
13928 }
13929 return NULL;
13930 }
13931
13932
13933 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj;
13935 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13936 wxString *arg2 = 0 ;
13937 bool temp2 = false ;
13938 PyObject * obj0 = 0 ;
13939 PyObject * obj1 = 0 ;
13940 char *kwnames[] = {
13941 (char *) "self",(char *) "shortDesc", NULL
13942 };
13943
13944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13946 if (SWIG_arg_fail(1)) SWIG_fail;
13947 {
13948 arg2 = wxString_in_helper(obj1);
13949 if (arg2 == NULL) SWIG_fail;
13950 temp2 = true;
13951 }
13952 {
13953 PyThreadState* __tstate = wxPyBeginAllowThreads();
13954 (arg1)->SetShortDesc((wxString const &)*arg2);
13955
13956 wxPyEndAllowThreads(__tstate);
13957 if (PyErr_Occurred()) SWIG_fail;
13958 }
13959 Py_INCREF(Py_None); resultobj = Py_None;
13960 {
13961 if (temp2)
13962 delete arg2;
13963 }
13964 return resultobj;
13965 fail:
13966 {
13967 if (temp2)
13968 delete arg2;
13969 }
13970 return NULL;
13971 }
13972
13973
13974 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj;
13976 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13977 wxString *result;
13978 PyObject * obj0 = 0 ;
13979 char *kwnames[] = {
13980 (char *) "self", NULL
13981 };
13982
13983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13985 if (SWIG_arg_fail(1)) SWIG_fail;
13986 {
13987 PyThreadState* __tstate = wxPyBeginAllowThreads();
13988 {
13989 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13990 result = (wxString *) &_result_ref;
13991 }
13992
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 {
13997 #if wxUSE_UNICODE
13998 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13999 #else
14000 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14001 #endif
14002 }
14003 return resultobj;
14004 fail:
14005 return NULL;
14006 }
14007
14008
14009 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14010 PyObject *resultobj;
14011 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14012 wxString *result;
14013 PyObject * obj0 = 0 ;
14014 char *kwnames[] = {
14015 (char *) "self", NULL
14016 };
14017
14018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
14019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14020 if (SWIG_arg_fail(1)) SWIG_fail;
14021 {
14022 PyThreadState* __tstate = wxPyBeginAllowThreads();
14023 {
14024 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
14025 result = (wxString *) &_result_ref;
14026 }
14027
14028 wxPyEndAllowThreads(__tstate);
14029 if (PyErr_Occurred()) SWIG_fail;
14030 }
14031 {
14032 #if wxUSE_UNICODE
14033 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14034 #else
14035 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14036 #endif
14037 }
14038 return resultobj;
14039 fail:
14040 return NULL;
14041 }
14042
14043
14044 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14045 PyObject *resultobj;
14046 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14047 wxString *result;
14048 PyObject * obj0 = 0 ;
14049 char *kwnames[] = {
14050 (char *) "self", NULL
14051 };
14052
14053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14055 if (SWIG_arg_fail(1)) SWIG_fail;
14056 {
14057 PyThreadState* __tstate = wxPyBeginAllowThreads();
14058 {
14059 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14060 result = (wxString *) &_result_ref;
14061 }
14062
14063 wxPyEndAllowThreads(__tstate);
14064 if (PyErr_Occurred()) SWIG_fail;
14065 }
14066 {
14067 #if wxUSE_UNICODE
14068 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14069 #else
14070 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14071 #endif
14072 }
14073 return resultobj;
14074 fail:
14075 return NULL;
14076 }
14077
14078
14079 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14080 PyObject *resultobj;
14081 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14082 wxString *result;
14083 PyObject * obj0 = 0 ;
14084 char *kwnames[] = {
14085 (char *) "self", NULL
14086 };
14087
14088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14090 if (SWIG_arg_fail(1)) SWIG_fail;
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 {
14094 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14095 result = (wxString *) &_result_ref;
14096 }
14097
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 {
14102 #if wxUSE_UNICODE
14103 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14104 #else
14105 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14106 #endif
14107 }
14108 return resultobj;
14109 fail:
14110 return NULL;
14111 }
14112
14113
14114 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14115 PyObject *resultobj;
14116 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14117 wxString *result;
14118 PyObject * obj0 = 0 ;
14119 char *kwnames[] = {
14120 (char *) "self", NULL
14121 };
14122
14123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14125 if (SWIG_arg_fail(1)) SWIG_fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 {
14129 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14130 result = (wxString *) &_result_ref;
14131 }
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 {
14137 #if wxUSE_UNICODE
14138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14139 #else
14140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14141 #endif
14142 }
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj;
14151 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14152 wxArrayString *result;
14153 PyObject * obj0 = 0 ;
14154 char *kwnames[] = {
14155 (char *) "self", NULL
14156 };
14157
14158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14160 if (SWIG_arg_fail(1)) SWIG_fail;
14161 {
14162 PyThreadState* __tstate = wxPyBeginAllowThreads();
14163 {
14164 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14165 result = (wxArrayString *) &_result_ref;
14166 }
14167
14168 wxPyEndAllowThreads(__tstate);
14169 if (PyErr_Occurred()) SWIG_fail;
14170 }
14171 {
14172 resultobj = wxArrayString2PyList_helper(*result);
14173 }
14174 return resultobj;
14175 fail:
14176 return NULL;
14177 }
14178
14179
14180 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14181 PyObject *resultobj;
14182 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14183 int result;
14184 PyObject * obj0 = 0 ;
14185 char *kwnames[] = {
14186 (char *) "self", NULL
14187 };
14188
14189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14191 if (SWIG_arg_fail(1)) SWIG_fail;
14192 {
14193 PyThreadState* __tstate = wxPyBeginAllowThreads();
14194 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14195
14196 wxPyEndAllowThreads(__tstate);
14197 if (PyErr_Occurred()) SWIG_fail;
14198 }
14199 {
14200 resultobj = SWIG_From_int((int)(result));
14201 }
14202 return resultobj;
14203 fail:
14204 return NULL;
14205 }
14206
14207
14208 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14211 wxString *result;
14212 PyObject * obj0 = 0 ;
14213 char *kwnames[] = {
14214 (char *) "self", NULL
14215 };
14216
14217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14219 if (SWIG_arg_fail(1)) SWIG_fail;
14220 {
14221 PyThreadState* __tstate = wxPyBeginAllowThreads();
14222 {
14223 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14224 result = (wxString *) &_result_ref;
14225 }
14226
14227 wxPyEndAllowThreads(__tstate);
14228 if (PyErr_Occurred()) SWIG_fail;
14229 }
14230 {
14231 #if wxUSE_UNICODE
14232 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14233 #else
14234 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14235 #endif
14236 }
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14246 int result;
14247 PyObject * obj0 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 resultobj = SWIG_From_int((int)(result));
14264 }
14265 return resultobj;
14266 fail:
14267 return NULL;
14268 }
14269
14270
14271 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14272 PyObject *obj;
14273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14274 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14275 Py_INCREF(obj);
14276 return Py_BuildValue((char *)"");
14277 }
14278 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14279 PyObject *resultobj;
14280 wxFileTypeInfo *arg1 = 0 ;
14281 wxFileType *result;
14282 PyObject * obj0 = 0 ;
14283 char *kwnames[] = {
14284 (char *) "ftInfo", NULL
14285 };
14286
14287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14288 {
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 if (arg1 == NULL) {
14292 SWIG_null_ref("wxFileTypeInfo");
14293 }
14294 if (SWIG_arg_fail(1)) SWIG_fail;
14295 }
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14299
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj;
14312 wxFileType *arg1 = (wxFileType *) 0 ;
14313 PyObject * obj0 = 0 ;
14314 char *kwnames[] = {
14315 (char *) "self", NULL
14316 };
14317
14318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14320 if (SWIG_arg_fail(1)) SWIG_fail;
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 delete arg1;
14324
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 Py_INCREF(Py_None); resultobj = Py_None;
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj;
14337 wxFileType *arg1 = (wxFileType *) 0 ;
14338 PyObject *result;
14339 PyObject * obj0 = 0 ;
14340 char *kwnames[] = {
14341 (char *) "self", NULL
14342 };
14343
14344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14346 if (SWIG_arg_fail(1)) SWIG_fail;
14347 {
14348 PyThreadState* __tstate = wxPyBeginAllowThreads();
14349 result = (PyObject *)wxFileType_GetMimeType(arg1);
14350
14351 wxPyEndAllowThreads(__tstate);
14352 if (PyErr_Occurred()) SWIG_fail;
14353 }
14354 resultobj = result;
14355 return resultobj;
14356 fail:
14357 return NULL;
14358 }
14359
14360
14361 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14362 PyObject *resultobj;
14363 wxFileType *arg1 = (wxFileType *) 0 ;
14364 PyObject *result;
14365 PyObject * obj0 = 0 ;
14366 char *kwnames[] = {
14367 (char *) "self", NULL
14368 };
14369
14370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14372 if (SWIG_arg_fail(1)) SWIG_fail;
14373 {
14374 PyThreadState* __tstate = wxPyBeginAllowThreads();
14375 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14376
14377 wxPyEndAllowThreads(__tstate);
14378 if (PyErr_Occurred()) SWIG_fail;
14379 }
14380 resultobj = result;
14381 return resultobj;
14382 fail:
14383 return NULL;
14384 }
14385
14386
14387 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14388 PyObject *resultobj;
14389 wxFileType *arg1 = (wxFileType *) 0 ;
14390 PyObject *result;
14391 PyObject * obj0 = 0 ;
14392 char *kwnames[] = {
14393 (char *) "self", NULL
14394 };
14395
14396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14398 if (SWIG_arg_fail(1)) SWIG_fail;
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 result = (PyObject *)wxFileType_GetExtensions(arg1);
14402
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 resultobj = result;
14407 return resultobj;
14408 fail:
14409 return NULL;
14410 }
14411
14412
14413 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14414 PyObject *resultobj;
14415 wxFileType *arg1 = (wxFileType *) 0 ;
14416 wxIcon *result;
14417 PyObject * obj0 = 0 ;
14418 char *kwnames[] = {
14419 (char *) "self", NULL
14420 };
14421
14422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14424 if (SWIG_arg_fail(1)) SWIG_fail;
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (wxIcon *)wxFileType_GetIcon(arg1);
14428
14429 wxPyEndAllowThreads(__tstate);
14430 if (PyErr_Occurred()) SWIG_fail;
14431 }
14432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14433 return resultobj;
14434 fail:
14435 return NULL;
14436 }
14437
14438
14439 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14440 PyObject *resultobj;
14441 wxFileType *arg1 = (wxFileType *) 0 ;
14442 PyObject *result;
14443 PyObject * obj0 = 0 ;
14444 char *kwnames[] = {
14445 (char *) "self", NULL
14446 };
14447
14448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14450 if (SWIG_arg_fail(1)) SWIG_fail;
14451 {
14452 PyThreadState* __tstate = wxPyBeginAllowThreads();
14453 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14454
14455 wxPyEndAllowThreads(__tstate);
14456 if (PyErr_Occurred()) SWIG_fail;
14457 }
14458 resultobj = result;
14459 return resultobj;
14460 fail:
14461 return NULL;
14462 }
14463
14464
14465 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14466 PyObject *resultobj;
14467 wxFileType *arg1 = (wxFileType *) 0 ;
14468 PyObject *result;
14469 PyObject * obj0 = 0 ;
14470 char *kwnames[] = {
14471 (char *) "self", NULL
14472 };
14473
14474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14476 if (SWIG_arg_fail(1)) SWIG_fail;
14477 {
14478 PyThreadState* __tstate = wxPyBeginAllowThreads();
14479 result = (PyObject *)wxFileType_GetDescription(arg1);
14480
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 resultobj = result;
14485 return resultobj;
14486 fail:
14487 return NULL;
14488 }
14489
14490
14491 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj;
14493 wxFileType *arg1 = (wxFileType *) 0 ;
14494 wxString *arg2 = 0 ;
14495 wxString const &arg3_defvalue = wxPyEmptyString ;
14496 wxString *arg3 = (wxString *) &arg3_defvalue ;
14497 PyObject *result;
14498 bool temp2 = false ;
14499 bool temp3 = false ;
14500 PyObject * obj0 = 0 ;
14501 PyObject * obj1 = 0 ;
14502 PyObject * obj2 = 0 ;
14503 char *kwnames[] = {
14504 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14505 };
14506
14507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14509 if (SWIG_arg_fail(1)) SWIG_fail;
14510 {
14511 arg2 = wxString_in_helper(obj1);
14512 if (arg2 == NULL) SWIG_fail;
14513 temp2 = true;
14514 }
14515 if (obj2) {
14516 {
14517 arg3 = wxString_in_helper(obj2);
14518 if (arg3 == NULL) SWIG_fail;
14519 temp3 = true;
14520 }
14521 }
14522 {
14523 PyThreadState* __tstate = wxPyBeginAllowThreads();
14524 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14525
14526 wxPyEndAllowThreads(__tstate);
14527 if (PyErr_Occurred()) SWIG_fail;
14528 }
14529 resultobj = result;
14530 {
14531 if (temp2)
14532 delete arg2;
14533 }
14534 {
14535 if (temp3)
14536 delete arg3;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (temp2)
14542 delete arg2;
14543 }
14544 {
14545 if (temp3)
14546 delete arg3;
14547 }
14548 return NULL;
14549 }
14550
14551
14552 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14553 PyObject *resultobj;
14554 wxFileType *arg1 = (wxFileType *) 0 ;
14555 wxString *arg2 = 0 ;
14556 wxString const &arg3_defvalue = wxPyEmptyString ;
14557 wxString *arg3 = (wxString *) &arg3_defvalue ;
14558 PyObject *result;
14559 bool temp2 = false ;
14560 bool temp3 = false ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 PyObject * obj2 = 0 ;
14564 char *kwnames[] = {
14565 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14566 };
14567
14568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14570 if (SWIG_arg_fail(1)) SWIG_fail;
14571 {
14572 arg2 = wxString_in_helper(obj1);
14573 if (arg2 == NULL) SWIG_fail;
14574 temp2 = true;
14575 }
14576 if (obj2) {
14577 {
14578 arg3 = wxString_in_helper(obj2);
14579 if (arg3 == NULL) SWIG_fail;
14580 temp3 = true;
14581 }
14582 }
14583 {
14584 PyThreadState* __tstate = wxPyBeginAllowThreads();
14585 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14586
14587 wxPyEndAllowThreads(__tstate);
14588 if (PyErr_Occurred()) SWIG_fail;
14589 }
14590 resultobj = result;
14591 {
14592 if (temp2)
14593 delete arg2;
14594 }
14595 {
14596 if (temp3)
14597 delete arg3;
14598 }
14599 return resultobj;
14600 fail:
14601 {
14602 if (temp2)
14603 delete arg2;
14604 }
14605 {
14606 if (temp3)
14607 delete arg3;
14608 }
14609 return NULL;
14610 }
14611
14612
14613 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj;
14615 wxFileType *arg1 = (wxFileType *) 0 ;
14616 wxString *arg2 = 0 ;
14617 wxString const &arg3_defvalue = wxPyEmptyString ;
14618 wxString *arg3 = (wxString *) &arg3_defvalue ;
14619 PyObject *result;
14620 bool temp2 = false ;
14621 bool temp3 = false ;
14622 PyObject * obj0 = 0 ;
14623 PyObject * obj1 = 0 ;
14624 PyObject * obj2 = 0 ;
14625 char *kwnames[] = {
14626 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14627 };
14628
14629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14631 if (SWIG_arg_fail(1)) SWIG_fail;
14632 {
14633 arg2 = wxString_in_helper(obj1);
14634 if (arg2 == NULL) SWIG_fail;
14635 temp2 = true;
14636 }
14637 if (obj2) {
14638 {
14639 arg3 = wxString_in_helper(obj2);
14640 if (arg3 == NULL) SWIG_fail;
14641 temp3 = true;
14642 }
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 resultobj = result;
14652 {
14653 if (temp2)
14654 delete arg2;
14655 }
14656 {
14657 if (temp3)
14658 delete arg3;
14659 }
14660 return resultobj;
14661 fail:
14662 {
14663 if (temp2)
14664 delete arg2;
14665 }
14666 {
14667 if (temp3)
14668 delete arg3;
14669 }
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxFileType *arg1 = (wxFileType *) 0 ;
14677 wxString *arg2 = 0 ;
14678 wxString *arg3 = 0 ;
14679 bool arg4 = (bool) true ;
14680 bool result;
14681 bool temp2 = false ;
14682 bool temp3 = false ;
14683 PyObject * obj0 = 0 ;
14684 PyObject * obj1 = 0 ;
14685 PyObject * obj2 = 0 ;
14686 PyObject * obj3 = 0 ;
14687 char *kwnames[] = {
14688 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14689 };
14690
14691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14693 if (SWIG_arg_fail(1)) SWIG_fail;
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 {
14700 arg3 = wxString_in_helper(obj2);
14701 if (arg3 == NULL) SWIG_fail;
14702 temp3 = true;
14703 }
14704 if (obj3) {
14705 {
14706 arg4 = (bool)(SWIG_As_bool(obj3));
14707 if (SWIG_arg_fail(4)) SWIG_fail;
14708 }
14709 }
14710 {
14711 PyThreadState* __tstate = wxPyBeginAllowThreads();
14712 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14713
14714 wxPyEndAllowThreads(__tstate);
14715 if (PyErr_Occurred()) SWIG_fail;
14716 }
14717 {
14718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14719 }
14720 {
14721 if (temp2)
14722 delete arg2;
14723 }
14724 {
14725 if (temp3)
14726 delete arg3;
14727 }
14728 return resultobj;
14729 fail:
14730 {
14731 if (temp2)
14732 delete arg2;
14733 }
14734 {
14735 if (temp3)
14736 delete arg3;
14737 }
14738 return NULL;
14739 }
14740
14741
14742 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14743 PyObject *resultobj;
14744 wxFileType *arg1 = (wxFileType *) 0 ;
14745 wxString const &arg2_defvalue = wxPyEmptyString ;
14746 wxString *arg2 = (wxString *) &arg2_defvalue ;
14747 int arg3 = (int) 0 ;
14748 bool result;
14749 bool temp2 = false ;
14750 PyObject * obj0 = 0 ;
14751 PyObject * obj1 = 0 ;
14752 PyObject * obj2 = 0 ;
14753 char *kwnames[] = {
14754 (char *) "self",(char *) "cmd",(char *) "index", NULL
14755 };
14756
14757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14759 if (SWIG_arg_fail(1)) SWIG_fail;
14760 if (obj1) {
14761 {
14762 arg2 = wxString_in_helper(obj1);
14763 if (arg2 == NULL) SWIG_fail;
14764 temp2 = true;
14765 }
14766 }
14767 if (obj2) {
14768 {
14769 arg3 = (int)(SWIG_As_int(obj2));
14770 if (SWIG_arg_fail(3)) SWIG_fail;
14771 }
14772 }
14773 {
14774 PyThreadState* __tstate = wxPyBeginAllowThreads();
14775 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14776
14777 wxPyEndAllowThreads(__tstate);
14778 if (PyErr_Occurred()) SWIG_fail;
14779 }
14780 {
14781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14782 }
14783 {
14784 if (temp2)
14785 delete arg2;
14786 }
14787 return resultobj;
14788 fail:
14789 {
14790 if (temp2)
14791 delete arg2;
14792 }
14793 return NULL;
14794 }
14795
14796
14797 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14798 PyObject *resultobj;
14799 wxFileType *arg1 = (wxFileType *) 0 ;
14800 bool result;
14801 PyObject * obj0 = 0 ;
14802 char *kwnames[] = {
14803 (char *) "self", NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14808 if (SWIG_arg_fail(1)) SWIG_fail;
14809 {
14810 PyThreadState* __tstate = wxPyBeginAllowThreads();
14811 result = (bool)(arg1)->Unassociate();
14812
14813 wxPyEndAllowThreads(__tstate);
14814 if (PyErr_Occurred()) SWIG_fail;
14815 }
14816 {
14817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14818 }
14819 return resultobj;
14820 fail:
14821 return NULL;
14822 }
14823
14824
14825 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14826 PyObject *resultobj;
14827 wxString *arg1 = 0 ;
14828 wxString *arg2 = 0 ;
14829 wxString const &arg3_defvalue = wxPyEmptyString ;
14830 wxString *arg3 = (wxString *) &arg3_defvalue ;
14831 wxString result;
14832 bool temp1 = false ;
14833 bool temp2 = false ;
14834 bool temp3 = false ;
14835 PyObject * obj0 = 0 ;
14836 PyObject * obj1 = 0 ;
14837 PyObject * obj2 = 0 ;
14838 char *kwnames[] = {
14839 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14840 };
14841
14842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14843 {
14844 arg1 = wxString_in_helper(obj0);
14845 if (arg1 == NULL) SWIG_fail;
14846 temp1 = true;
14847 }
14848 {
14849 arg2 = wxString_in_helper(obj1);
14850 if (arg2 == NULL) SWIG_fail;
14851 temp2 = true;
14852 }
14853 if (obj2) {
14854 {
14855 arg3 = wxString_in_helper(obj2);
14856 if (arg3 == NULL) SWIG_fail;
14857 temp3 = true;
14858 }
14859 }
14860 {
14861 PyThreadState* __tstate = wxPyBeginAllowThreads();
14862 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14863
14864 wxPyEndAllowThreads(__tstate);
14865 if (PyErr_Occurred()) SWIG_fail;
14866 }
14867 {
14868 #if wxUSE_UNICODE
14869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14870 #else
14871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14872 #endif
14873 }
14874 {
14875 if (temp1)
14876 delete arg1;
14877 }
14878 {
14879 if (temp2)
14880 delete arg2;
14881 }
14882 {
14883 if (temp3)
14884 delete arg3;
14885 }
14886 return resultobj;
14887 fail:
14888 {
14889 if (temp1)
14890 delete arg1;
14891 }
14892 {
14893 if (temp2)
14894 delete arg2;
14895 }
14896 {
14897 if (temp3)
14898 delete arg3;
14899 }
14900 return NULL;
14901 }
14902
14903
14904 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14905 PyObject *obj;
14906 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14907 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14908 Py_INCREF(obj);
14909 return Py_BuildValue((char *)"");
14910 }
14911 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14912 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14913 return 1;
14914 }
14915
14916
14917 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14918 PyObject *pyobj;
14919
14920 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14921 return pyobj;
14922 }
14923
14924
14925 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxString *arg1 = 0 ;
14928 wxString *arg2 = 0 ;
14929 bool result;
14930 bool temp1 = false ;
14931 bool temp2 = false ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 char *kwnames[] = {
14935 (char *) "mimeType",(char *) "wildcard", NULL
14936 };
14937
14938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14939 {
14940 arg1 = wxString_in_helper(obj0);
14941 if (arg1 == NULL) SWIG_fail;
14942 temp1 = true;
14943 }
14944 {
14945 arg2 = wxString_in_helper(obj1);
14946 if (arg2 == NULL) SWIG_fail;
14947 temp2 = true;
14948 }
14949 {
14950 PyThreadState* __tstate = wxPyBeginAllowThreads();
14951 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14952
14953 wxPyEndAllowThreads(__tstate);
14954 if (PyErr_Occurred()) SWIG_fail;
14955 }
14956 {
14957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14958 }
14959 {
14960 if (temp1)
14961 delete arg1;
14962 }
14963 {
14964 if (temp2)
14965 delete arg2;
14966 }
14967 return resultobj;
14968 fail:
14969 {
14970 if (temp1)
14971 delete arg1;
14972 }
14973 {
14974 if (temp2)
14975 delete arg2;
14976 }
14977 return NULL;
14978 }
14979
14980
14981 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14982 PyObject *resultobj;
14983 wxMimeTypesManager *result;
14984 char *kwnames[] = {
14985 NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14992
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
15004 PyObject *resultobj;
15005 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15006 int arg2 = (int) wxMAILCAP_ALL ;
15007 wxString const &arg3_defvalue = wxPyEmptyString ;
15008 wxString *arg3 = (wxString *) &arg3_defvalue ;
15009 bool temp3 = false ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 PyObject * obj2 = 0 ;
15013 char *kwnames[] = {
15014 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
15015 };
15016
15017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
15018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15019 if (SWIG_arg_fail(1)) SWIG_fail;
15020 if (obj1) {
15021 {
15022 arg2 = (int)(SWIG_As_int(obj1));
15023 if (SWIG_arg_fail(2)) SWIG_fail;
15024 }
15025 }
15026 if (obj2) {
15027 {
15028 arg3 = wxString_in_helper(obj2);
15029 if (arg3 == NULL) SWIG_fail;
15030 temp3 = true;
15031 }
15032 }
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 (arg1)->Initialize(arg2,(wxString const &)*arg3);
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 Py_INCREF(Py_None); resultobj = Py_None;
15041 {
15042 if (temp3)
15043 delete arg3;
15044 }
15045 return resultobj;
15046 fail:
15047 {
15048 if (temp3)
15049 delete arg3;
15050 }
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15058 PyObject * obj0 = 0 ;
15059 char *kwnames[] = {
15060 (char *) "self", NULL
15061 };
15062
15063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15065 if (SWIG_arg_fail(1)) SWIG_fail;
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 (arg1)->ClearData();
15069
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 Py_INCREF(Py_None); resultobj = Py_None;
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15083 wxString *arg2 = 0 ;
15084 wxFileType *result;
15085 bool temp2 = false ;
15086 PyObject * obj0 = 0 ;
15087 PyObject * obj1 = 0 ;
15088 char *kwnames[] = {
15089 (char *) "self",(char *) "ext", NULL
15090 };
15091
15092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15094 if (SWIG_arg_fail(1)) SWIG_fail;
15095 {
15096 arg2 = wxString_in_helper(obj1);
15097 if (arg2 == NULL) SWIG_fail;
15098 temp2 = true;
15099 }
15100 {
15101 PyThreadState* __tstate = wxPyBeginAllowThreads();
15102 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15103
15104 wxPyEndAllowThreads(__tstate);
15105 if (PyErr_Occurred()) SWIG_fail;
15106 }
15107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15108 {
15109 if (temp2)
15110 delete arg2;
15111 }
15112 return resultobj;
15113 fail:
15114 {
15115 if (temp2)
15116 delete arg2;
15117 }
15118 return NULL;
15119 }
15120
15121
15122 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj;
15124 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15125 wxString *arg2 = 0 ;
15126 wxFileType *result;
15127 bool temp2 = false ;
15128 PyObject * obj0 = 0 ;
15129 PyObject * obj1 = 0 ;
15130 char *kwnames[] = {
15131 (char *) "self",(char *) "mimeType", NULL
15132 };
15133
15134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15136 if (SWIG_arg_fail(1)) SWIG_fail;
15137 {
15138 arg2 = wxString_in_helper(obj1);
15139 if (arg2 == NULL) SWIG_fail;
15140 temp2 = true;
15141 }
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15145
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15150 {
15151 if (temp2)
15152 delete arg2;
15153 }
15154 return resultobj;
15155 fail:
15156 {
15157 if (temp2)
15158 delete arg2;
15159 }
15160 return NULL;
15161 }
15162
15163
15164 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15165 PyObject *resultobj;
15166 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15167 wxString *arg2 = 0 ;
15168 bool arg3 = (bool) false ;
15169 bool result;
15170 bool temp2 = false ;
15171 PyObject * obj0 = 0 ;
15172 PyObject * obj1 = 0 ;
15173 PyObject * obj2 = 0 ;
15174 char *kwnames[] = {
15175 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15176 };
15177
15178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15180 if (SWIG_arg_fail(1)) SWIG_fail;
15181 {
15182 arg2 = wxString_in_helper(obj1);
15183 if (arg2 == NULL) SWIG_fail;
15184 temp2 = true;
15185 }
15186 if (obj2) {
15187 {
15188 arg3 = (bool)(SWIG_As_bool(obj2));
15189 if (SWIG_arg_fail(3)) SWIG_fail;
15190 }
15191 }
15192 {
15193 PyThreadState* __tstate = wxPyBeginAllowThreads();
15194 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15195
15196 wxPyEndAllowThreads(__tstate);
15197 if (PyErr_Occurred()) SWIG_fail;
15198 }
15199 {
15200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15201 }
15202 {
15203 if (temp2)
15204 delete arg2;
15205 }
15206 return resultobj;
15207 fail:
15208 {
15209 if (temp2)
15210 delete arg2;
15211 }
15212 return NULL;
15213 }
15214
15215
15216 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15217 PyObject *resultobj;
15218 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15219 wxString *arg2 = 0 ;
15220 bool result;
15221 bool temp2 = false ;
15222 PyObject * obj0 = 0 ;
15223 PyObject * obj1 = 0 ;
15224 char *kwnames[] = {
15225 (char *) "self",(char *) "filename", NULL
15226 };
15227
15228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15230 if (SWIG_arg_fail(1)) SWIG_fail;
15231 {
15232 arg2 = wxString_in_helper(obj1);
15233 if (arg2 == NULL) SWIG_fail;
15234 temp2 = true;
15235 }
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15239
15240 wxPyEndAllowThreads(__tstate);
15241 if (PyErr_Occurred()) SWIG_fail;
15242 }
15243 {
15244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15245 }
15246 {
15247 if (temp2)
15248 delete arg2;
15249 }
15250 return resultobj;
15251 fail:
15252 {
15253 if (temp2)
15254 delete arg2;
15255 }
15256 return NULL;
15257 }
15258
15259
15260 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15261 PyObject *resultobj;
15262 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15263 PyObject *result;
15264 PyObject * obj0 = 0 ;
15265 char *kwnames[] = {
15266 (char *) "self", NULL
15267 };
15268
15269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15271 if (SWIG_arg_fail(1)) SWIG_fail;
15272 {
15273 PyThreadState* __tstate = wxPyBeginAllowThreads();
15274 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15275
15276 wxPyEndAllowThreads(__tstate);
15277 if (PyErr_Occurred()) SWIG_fail;
15278 }
15279 resultobj = result;
15280 return resultobj;
15281 fail:
15282 return NULL;
15283 }
15284
15285
15286 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15287 PyObject *resultobj;
15288 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15289 wxFileTypeInfo *arg2 = 0 ;
15290 PyObject * obj0 = 0 ;
15291 PyObject * obj1 = 0 ;
15292 char *kwnames[] = {
15293 (char *) "self",(char *) "ft", NULL
15294 };
15295
15296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15298 if (SWIG_arg_fail(1)) SWIG_fail;
15299 {
15300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15301 if (SWIG_arg_fail(2)) SWIG_fail;
15302 if (arg2 == NULL) {
15303 SWIG_null_ref("wxFileTypeInfo");
15304 }
15305 if (SWIG_arg_fail(2)) SWIG_fail;
15306 }
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 Py_INCREF(Py_None); resultobj = Py_None;
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15322 PyObject *resultobj;
15323 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15324 wxFileTypeInfo *arg2 = 0 ;
15325 wxFileType *result;
15326 PyObject * obj0 = 0 ;
15327 PyObject * obj1 = 0 ;
15328 char *kwnames[] = {
15329 (char *) "self",(char *) "ftInfo", NULL
15330 };
15331
15332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",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 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15346
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15360 wxFileType *arg2 = (wxFileType *) 0 ;
15361 bool result;
15362 PyObject * obj0 = 0 ;
15363 PyObject * obj1 = 0 ;
15364 char *kwnames[] = {
15365 (char *) "self",(char *) "ft", NULL
15366 };
15367
15368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15372 if (SWIG_arg_fail(2)) SWIG_fail;
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (bool)(arg1)->Unassociate(arg2);
15376
15377 wxPyEndAllowThreads(__tstate);
15378 if (PyErr_Occurred()) SWIG_fail;
15379 }
15380 {
15381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15382 }
15383 return resultobj;
15384 fail:
15385 return NULL;
15386 }
15387
15388
15389 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15390 PyObject *resultobj;
15391 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15392 PyObject * obj0 = 0 ;
15393 char *kwnames[] = {
15394 (char *) "self", NULL
15395 };
15396
15397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15399 if (SWIG_arg_fail(1)) SWIG_fail;
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 delete arg1;
15403
15404 wxPyEndAllowThreads(__tstate);
15405 if (PyErr_Occurred()) SWIG_fail;
15406 }
15407 Py_INCREF(Py_None); resultobj = Py_None;
15408 return resultobj;
15409 fail:
15410 return NULL;
15411 }
15412
15413
15414 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15415 PyObject *obj;
15416 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15417 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15418 Py_INCREF(obj);
15419 return Py_BuildValue((char *)"");
15420 }
15421 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15422 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15423 return 1;
15424 }
15425
15426
15427 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15428 PyObject *pyobj;
15429
15430 {
15431 #if wxUSE_UNICODE
15432 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15433 #else
15434 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15435 #endif
15436 }
15437 return pyobj;
15438 }
15439
15440
15441 static int _wrap_ART_MENU_set(PyObject *) {
15442 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15443 return 1;
15444 }
15445
15446
15447 static PyObject *_wrap_ART_MENU_get(void) {
15448 PyObject *pyobj;
15449
15450 {
15451 #if wxUSE_UNICODE
15452 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15453 #else
15454 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15455 #endif
15456 }
15457 return pyobj;
15458 }
15459
15460
15461 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15462 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15463 return 1;
15464 }
15465
15466
15467 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15468 PyObject *pyobj;
15469
15470 {
15471 #if wxUSE_UNICODE
15472 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15473 #else
15474 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15475 #endif
15476 }
15477 return pyobj;
15478 }
15479
15480
15481 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15482 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15483 return 1;
15484 }
15485
15486
15487 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15488 PyObject *pyobj;
15489
15490 {
15491 #if wxUSE_UNICODE
15492 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15493 #else
15494 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15495 #endif
15496 }
15497 return pyobj;
15498 }
15499
15500
15501 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15502 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15503 return 1;
15504 }
15505
15506
15507 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15508 PyObject *pyobj;
15509
15510 {
15511 #if wxUSE_UNICODE
15512 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15513 #else
15514 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15515 #endif
15516 }
15517 return pyobj;
15518 }
15519
15520
15521 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15522 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15523 return 1;
15524 }
15525
15526
15527 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15528 PyObject *pyobj;
15529
15530 {
15531 #if wxUSE_UNICODE
15532 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15533 #else
15534 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15535 #endif
15536 }
15537 return pyobj;
15538 }
15539
15540
15541 static int _wrap_ART_BUTTON_set(PyObject *) {
15542 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15543 return 1;
15544 }
15545
15546
15547 static PyObject *_wrap_ART_BUTTON_get(void) {
15548 PyObject *pyobj;
15549
15550 {
15551 #if wxUSE_UNICODE
15552 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15553 #else
15554 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15555 #endif
15556 }
15557 return pyobj;
15558 }
15559
15560
15561 static int _wrap_ART_OTHER_set(PyObject *) {
15562 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15563 return 1;
15564 }
15565
15566
15567 static PyObject *_wrap_ART_OTHER_get(void) {
15568 PyObject *pyobj;
15569
15570 {
15571 #if wxUSE_UNICODE
15572 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15573 #else
15574 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15575 #endif
15576 }
15577 return pyobj;
15578 }
15579
15580
15581 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15582 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15583 return 1;
15584 }
15585
15586
15587 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15588 PyObject *pyobj;
15589
15590 {
15591 #if wxUSE_UNICODE
15592 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15593 #else
15594 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15595 #endif
15596 }
15597 return pyobj;
15598 }
15599
15600
15601 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15602 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15603 return 1;
15604 }
15605
15606
15607 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15608 PyObject *pyobj;
15609
15610 {
15611 #if wxUSE_UNICODE
15612 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15613 #else
15614 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15615 #endif
15616 }
15617 return pyobj;
15618 }
15619
15620
15621 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15622 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15623 return 1;
15624 }
15625
15626
15627 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15628 PyObject *pyobj;
15629
15630 {
15631 #if wxUSE_UNICODE
15632 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15633 #else
15634 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15635 #endif
15636 }
15637 return pyobj;
15638 }
15639
15640
15641 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15642 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15643 return 1;
15644 }
15645
15646
15647 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15648 PyObject *pyobj;
15649
15650 {
15651 #if wxUSE_UNICODE
15652 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15653 #else
15654 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15655 #endif
15656 }
15657 return pyobj;
15658 }
15659
15660
15661 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15662 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15663 return 1;
15664 }
15665
15666
15667 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15668 PyObject *pyobj;
15669
15670 {
15671 #if wxUSE_UNICODE
15672 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15673 #else
15674 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15675 #endif
15676 }
15677 return pyobj;
15678 }
15679
15680
15681 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15682 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15683 return 1;
15684 }
15685
15686
15687 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15688 PyObject *pyobj;
15689
15690 {
15691 #if wxUSE_UNICODE
15692 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15693 #else
15694 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15695 #endif
15696 }
15697 return pyobj;
15698 }
15699
15700
15701 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15702 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15703 return 1;
15704 }
15705
15706
15707 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15708 PyObject *pyobj;
15709
15710 {
15711 #if wxUSE_UNICODE
15712 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15713 #else
15714 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15715 #endif
15716 }
15717 return pyobj;
15718 }
15719
15720
15721 static int _wrap_ART_GO_BACK_set(PyObject *) {
15722 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15723 return 1;
15724 }
15725
15726
15727 static PyObject *_wrap_ART_GO_BACK_get(void) {
15728 PyObject *pyobj;
15729
15730 {
15731 #if wxUSE_UNICODE
15732 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15733 #else
15734 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15735 #endif
15736 }
15737 return pyobj;
15738 }
15739
15740
15741 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15742 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15743 return 1;
15744 }
15745
15746
15747 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15748 PyObject *pyobj;
15749
15750 {
15751 #if wxUSE_UNICODE
15752 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15753 #else
15754 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15755 #endif
15756 }
15757 return pyobj;
15758 }
15759
15760
15761 static int _wrap_ART_GO_UP_set(PyObject *) {
15762 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15763 return 1;
15764 }
15765
15766
15767 static PyObject *_wrap_ART_GO_UP_get(void) {
15768 PyObject *pyobj;
15769
15770 {
15771 #if wxUSE_UNICODE
15772 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15773 #else
15774 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15775 #endif
15776 }
15777 return pyobj;
15778 }
15779
15780
15781 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15782 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15783 return 1;
15784 }
15785
15786
15787 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15788 PyObject *pyobj;
15789
15790 {
15791 #if wxUSE_UNICODE
15792 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15793 #else
15794 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15795 #endif
15796 }
15797 return pyobj;
15798 }
15799
15800
15801 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15802 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15803 return 1;
15804 }
15805
15806
15807 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15808 PyObject *pyobj;
15809
15810 {
15811 #if wxUSE_UNICODE
15812 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15813 #else
15814 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15815 #endif
15816 }
15817 return pyobj;
15818 }
15819
15820
15821 static int _wrap_ART_GO_HOME_set(PyObject *) {
15822 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15823 return 1;
15824 }
15825
15826
15827 static PyObject *_wrap_ART_GO_HOME_get(void) {
15828 PyObject *pyobj;
15829
15830 {
15831 #if wxUSE_UNICODE
15832 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15833 #else
15834 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15835 #endif
15836 }
15837 return pyobj;
15838 }
15839
15840
15841 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15842 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15843 return 1;
15844 }
15845
15846
15847 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15848 PyObject *pyobj;
15849
15850 {
15851 #if wxUSE_UNICODE
15852 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15853 #else
15854 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15855 #endif
15856 }
15857 return pyobj;
15858 }
15859
15860
15861 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15862 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15863 return 1;
15864 }
15865
15866
15867 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15868 PyObject *pyobj;
15869
15870 {
15871 #if wxUSE_UNICODE
15872 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15873 #else
15874 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15875 #endif
15876 }
15877 return pyobj;
15878 }
15879
15880
15881 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15882 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15883 return 1;
15884 }
15885
15886
15887 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15888 PyObject *pyobj;
15889
15890 {
15891 #if wxUSE_UNICODE
15892 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15893 #else
15894 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15895 #endif
15896 }
15897 return pyobj;
15898 }
15899
15900
15901 static int _wrap_ART_PRINT_set(PyObject *) {
15902 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15903 return 1;
15904 }
15905
15906
15907 static PyObject *_wrap_ART_PRINT_get(void) {
15908 PyObject *pyobj;
15909
15910 {
15911 #if wxUSE_UNICODE
15912 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15913 #else
15914 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15915 #endif
15916 }
15917 return pyobj;
15918 }
15919
15920
15921 static int _wrap_ART_HELP_set(PyObject *) {
15922 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15923 return 1;
15924 }
15925
15926
15927 static PyObject *_wrap_ART_HELP_get(void) {
15928 PyObject *pyobj;
15929
15930 {
15931 #if wxUSE_UNICODE
15932 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15933 #else
15934 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15935 #endif
15936 }
15937 return pyobj;
15938 }
15939
15940
15941 static int _wrap_ART_TIP_set(PyObject *) {
15942 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15943 return 1;
15944 }
15945
15946
15947 static PyObject *_wrap_ART_TIP_get(void) {
15948 PyObject *pyobj;
15949
15950 {
15951 #if wxUSE_UNICODE
15952 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15953 #else
15954 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15955 #endif
15956 }
15957 return pyobj;
15958 }
15959
15960
15961 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15962 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15963 return 1;
15964 }
15965
15966
15967 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15968 PyObject *pyobj;
15969
15970 {
15971 #if wxUSE_UNICODE
15972 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15973 #else
15974 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15975 #endif
15976 }
15977 return pyobj;
15978 }
15979
15980
15981 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15982 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15983 return 1;
15984 }
15985
15986
15987 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15988 PyObject *pyobj;
15989
15990 {
15991 #if wxUSE_UNICODE
15992 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15993 #else
15994 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15995 #endif
15996 }
15997 return pyobj;
15998 }
15999
16000
16001 static int _wrap_ART_NEW_DIR_set(PyObject *) {
16002 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
16003 return 1;
16004 }
16005
16006
16007 static PyObject *_wrap_ART_NEW_DIR_get(void) {
16008 PyObject *pyobj;
16009
16010 {
16011 #if wxUSE_UNICODE
16012 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16013 #else
16014 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
16015 #endif
16016 }
16017 return pyobj;
16018 }
16019
16020
16021 static int _wrap_ART_HARDDISK_set(PyObject *) {
16022 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
16023 return 1;
16024 }
16025
16026
16027 static PyObject *_wrap_ART_HARDDISK_get(void) {
16028 PyObject *pyobj;
16029
16030 {
16031 #if wxUSE_UNICODE
16032 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16033 #else
16034 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
16035 #endif
16036 }
16037 return pyobj;
16038 }
16039
16040
16041 static int _wrap_ART_FLOPPY_set(PyObject *) {
16042 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
16043 return 1;
16044 }
16045
16046
16047 static PyObject *_wrap_ART_FLOPPY_get(void) {
16048 PyObject *pyobj;
16049
16050 {
16051 #if wxUSE_UNICODE
16052 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16053 #else
16054 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16055 #endif
16056 }
16057 return pyobj;
16058 }
16059
16060
16061 static int _wrap_ART_CDROM_set(PyObject *) {
16062 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16063 return 1;
16064 }
16065
16066
16067 static PyObject *_wrap_ART_CDROM_get(void) {
16068 PyObject *pyobj;
16069
16070 {
16071 #if wxUSE_UNICODE
16072 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16073 #else
16074 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16075 #endif
16076 }
16077 return pyobj;
16078 }
16079
16080
16081 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16082 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16083 return 1;
16084 }
16085
16086
16087 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16088 PyObject *pyobj;
16089
16090 {
16091 #if wxUSE_UNICODE
16092 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16093 #else
16094 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16095 #endif
16096 }
16097 return pyobj;
16098 }
16099
16100
16101 static int _wrap_ART_FOLDER_set(PyObject *) {
16102 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16103 return 1;
16104 }
16105
16106
16107 static PyObject *_wrap_ART_FOLDER_get(void) {
16108 PyObject *pyobj;
16109
16110 {
16111 #if wxUSE_UNICODE
16112 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16113 #else
16114 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16115 #endif
16116 }
16117 return pyobj;
16118 }
16119
16120
16121 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16122 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16123 return 1;
16124 }
16125
16126
16127 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16128 PyObject *pyobj;
16129
16130 {
16131 #if wxUSE_UNICODE
16132 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16133 #else
16134 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16135 #endif
16136 }
16137 return pyobj;
16138 }
16139
16140
16141 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16142 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16143 return 1;
16144 }
16145
16146
16147 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16148 PyObject *pyobj;
16149
16150 {
16151 #if wxUSE_UNICODE
16152 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16153 #else
16154 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16155 #endif
16156 }
16157 return pyobj;
16158 }
16159
16160
16161 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16162 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16163 return 1;
16164 }
16165
16166
16167 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16168 PyObject *pyobj;
16169
16170 {
16171 #if wxUSE_UNICODE
16172 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16173 #else
16174 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16175 #endif
16176 }
16177 return pyobj;
16178 }
16179
16180
16181 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16182 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16183 return 1;
16184 }
16185
16186
16187 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16188 PyObject *pyobj;
16189
16190 {
16191 #if wxUSE_UNICODE
16192 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16193 #else
16194 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16195 #endif
16196 }
16197 return pyobj;
16198 }
16199
16200
16201 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16202 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16203 return 1;
16204 }
16205
16206
16207 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16208 PyObject *pyobj;
16209
16210 {
16211 #if wxUSE_UNICODE
16212 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16213 #else
16214 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16215 #endif
16216 }
16217 return pyobj;
16218 }
16219
16220
16221 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16222 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16223 return 1;
16224 }
16225
16226
16227 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16228 PyObject *pyobj;
16229
16230 {
16231 #if wxUSE_UNICODE
16232 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16233 #else
16234 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16235 #endif
16236 }
16237 return pyobj;
16238 }
16239
16240
16241 static int _wrap_ART_ERROR_set(PyObject *) {
16242 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16243 return 1;
16244 }
16245
16246
16247 static PyObject *_wrap_ART_ERROR_get(void) {
16248 PyObject *pyobj;
16249
16250 {
16251 #if wxUSE_UNICODE
16252 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16253 #else
16254 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16255 #endif
16256 }
16257 return pyobj;
16258 }
16259
16260
16261 static int _wrap_ART_QUESTION_set(PyObject *) {
16262 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16263 return 1;
16264 }
16265
16266
16267 static PyObject *_wrap_ART_QUESTION_get(void) {
16268 PyObject *pyobj;
16269
16270 {
16271 #if wxUSE_UNICODE
16272 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16273 #else
16274 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16275 #endif
16276 }
16277 return pyobj;
16278 }
16279
16280
16281 static int _wrap_ART_WARNING_set(PyObject *) {
16282 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16283 return 1;
16284 }
16285
16286
16287 static PyObject *_wrap_ART_WARNING_get(void) {
16288 PyObject *pyobj;
16289
16290 {
16291 #if wxUSE_UNICODE
16292 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16293 #else
16294 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16295 #endif
16296 }
16297 return pyobj;
16298 }
16299
16300
16301 static int _wrap_ART_INFORMATION_set(PyObject *) {
16302 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16303 return 1;
16304 }
16305
16306
16307 static PyObject *_wrap_ART_INFORMATION_get(void) {
16308 PyObject *pyobj;
16309
16310 {
16311 #if wxUSE_UNICODE
16312 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16313 #else
16314 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16315 #endif
16316 }
16317 return pyobj;
16318 }
16319
16320
16321 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16322 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16323 return 1;
16324 }
16325
16326
16327 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16328 PyObject *pyobj;
16329
16330 {
16331 #if wxUSE_UNICODE
16332 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16333 #else
16334 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16335 #endif
16336 }
16337 return pyobj;
16338 }
16339
16340
16341 static int _wrap_ART_COPY_set(PyObject *) {
16342 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16343 return 1;
16344 }
16345
16346
16347 static PyObject *_wrap_ART_COPY_get(void) {
16348 PyObject *pyobj;
16349
16350 {
16351 #if wxUSE_UNICODE
16352 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16353 #else
16354 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16355 #endif
16356 }
16357 return pyobj;
16358 }
16359
16360
16361 static int _wrap_ART_CUT_set(PyObject *) {
16362 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16363 return 1;
16364 }
16365
16366
16367 static PyObject *_wrap_ART_CUT_get(void) {
16368 PyObject *pyobj;
16369
16370 {
16371 #if wxUSE_UNICODE
16372 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16373 #else
16374 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16375 #endif
16376 }
16377 return pyobj;
16378 }
16379
16380
16381 static int _wrap_ART_PASTE_set(PyObject *) {
16382 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16383 return 1;
16384 }
16385
16386
16387 static PyObject *_wrap_ART_PASTE_get(void) {
16388 PyObject *pyobj;
16389
16390 {
16391 #if wxUSE_UNICODE
16392 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16393 #else
16394 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16395 #endif
16396 }
16397 return pyobj;
16398 }
16399
16400
16401 static int _wrap_ART_DELETE_set(PyObject *) {
16402 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16403 return 1;
16404 }
16405
16406
16407 static PyObject *_wrap_ART_DELETE_get(void) {
16408 PyObject *pyobj;
16409
16410 {
16411 #if wxUSE_UNICODE
16412 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16413 #else
16414 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16415 #endif
16416 }
16417 return pyobj;
16418 }
16419
16420
16421 static int _wrap_ART_UNDO_set(PyObject *) {
16422 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16423 return 1;
16424 }
16425
16426
16427 static PyObject *_wrap_ART_UNDO_get(void) {
16428 PyObject *pyobj;
16429
16430 {
16431 #if wxUSE_UNICODE
16432 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16433 #else
16434 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16435 #endif
16436 }
16437 return pyobj;
16438 }
16439
16440
16441 static int _wrap_ART_REDO_set(PyObject *) {
16442 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16443 return 1;
16444 }
16445
16446
16447 static PyObject *_wrap_ART_REDO_get(void) {
16448 PyObject *pyobj;
16449
16450 {
16451 #if wxUSE_UNICODE
16452 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16453 #else
16454 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16455 #endif
16456 }
16457 return pyobj;
16458 }
16459
16460
16461 static int _wrap_ART_QUIT_set(PyObject *) {
16462 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16463 return 1;
16464 }
16465
16466
16467 static PyObject *_wrap_ART_QUIT_get(void) {
16468 PyObject *pyobj;
16469
16470 {
16471 #if wxUSE_UNICODE
16472 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16473 #else
16474 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16475 #endif
16476 }
16477 return pyobj;
16478 }
16479
16480
16481 static int _wrap_ART_FIND_set(PyObject *) {
16482 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16483 return 1;
16484 }
16485
16486
16487 static PyObject *_wrap_ART_FIND_get(void) {
16488 PyObject *pyobj;
16489
16490 {
16491 #if wxUSE_UNICODE
16492 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16493 #else
16494 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16495 #endif
16496 }
16497 return pyobj;
16498 }
16499
16500
16501 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16502 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16503 return 1;
16504 }
16505
16506
16507 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16508 PyObject *pyobj;
16509
16510 {
16511 #if wxUSE_UNICODE
16512 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16513 #else
16514 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16515 #endif
16516 }
16517 return pyobj;
16518 }
16519
16520
16521 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16522 PyObject *resultobj;
16523 wxPyArtProvider *result;
16524 char *kwnames[] = {
16525 NULL
16526 };
16527
16528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16529 {
16530 if (!wxPyCheckForApp()) SWIG_fail;
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 result = (wxPyArtProvider *)new wxPyArtProvider();
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj;
16546 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16547 PyObject *arg2 = (PyObject *) 0 ;
16548 PyObject *arg3 = (PyObject *) 0 ;
16549 PyObject * obj0 = 0 ;
16550 PyObject * obj1 = 0 ;
16551 PyObject * obj2 = 0 ;
16552 char *kwnames[] = {
16553 (char *) "self",(char *) "self",(char *) "_class", NULL
16554 };
16555
16556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16558 if (SWIG_arg_fail(1)) SWIG_fail;
16559 arg2 = obj1;
16560 arg3 = obj2;
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 (arg1)->_setCallbackInfo(arg2,arg3);
16564
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 Py_INCREF(Py_None); resultobj = Py_None;
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj;
16577 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16578 PyObject * obj0 = 0 ;
16579 char *kwnames[] = {
16580 (char *) "provider", NULL
16581 };
16582
16583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16585 if (SWIG_arg_fail(1)) SWIG_fail;
16586 {
16587 PyThreadState* __tstate = wxPyBeginAllowThreads();
16588 wxPyArtProvider::PushProvider(arg1);
16589
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 Py_INCREF(Py_None); resultobj = Py_None;
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj;
16602 bool result;
16603 char *kwnames[] = {
16604 NULL
16605 };
16606
16607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16608 {
16609 PyThreadState* __tstate = wxPyBeginAllowThreads();
16610 result = (bool)wxPyArtProvider::PopProvider();
16611
16612 wxPyEndAllowThreads(__tstate);
16613 if (PyErr_Occurred()) SWIG_fail;
16614 }
16615 {
16616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16617 }
16618 return resultobj;
16619 fail:
16620 return NULL;
16621 }
16622
16623
16624 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16625 PyObject *resultobj;
16626 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16627 bool result;
16628 PyObject * obj0 = 0 ;
16629 char *kwnames[] = {
16630 (char *) "provider", NULL
16631 };
16632
16633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16635 if (SWIG_arg_fail(1)) SWIG_fail;
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16639
16640 wxPyEndAllowThreads(__tstate);
16641 if (PyErr_Occurred()) SWIG_fail;
16642 }
16643 {
16644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16645 }
16646 return resultobj;
16647 fail:
16648 return NULL;
16649 }
16650
16651
16652 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj;
16654 wxString *arg1 = 0 ;
16655 wxString const &arg2_defvalue = wxPyART_OTHER ;
16656 wxString *arg2 = (wxString *) &arg2_defvalue ;
16657 wxSize const &arg3_defvalue = wxDefaultSize ;
16658 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16659 wxBitmap result;
16660 bool temp1 = false ;
16661 bool temp2 = false ;
16662 wxSize temp3 ;
16663 PyObject * obj0 = 0 ;
16664 PyObject * obj1 = 0 ;
16665 PyObject * obj2 = 0 ;
16666 char *kwnames[] = {
16667 (char *) "id",(char *) "client",(char *) "size", NULL
16668 };
16669
16670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16671 {
16672 arg1 = wxString_in_helper(obj0);
16673 if (arg1 == NULL) SWIG_fail;
16674 temp1 = true;
16675 }
16676 if (obj1) {
16677 {
16678 arg2 = wxString_in_helper(obj1);
16679 if (arg2 == NULL) SWIG_fail;
16680 temp2 = true;
16681 }
16682 }
16683 if (obj2) {
16684 {
16685 arg3 = &temp3;
16686 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16687 }
16688 }
16689 {
16690 if (!wxPyCheckForApp()) SWIG_fail;
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 {
16698 wxBitmap * resultptr;
16699 resultptr = new wxBitmap((wxBitmap &)(result));
16700 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16701 }
16702 {
16703 if (temp1)
16704 delete arg1;
16705 }
16706 {
16707 if (temp2)
16708 delete arg2;
16709 }
16710 return resultobj;
16711 fail:
16712 {
16713 if (temp1)
16714 delete arg1;
16715 }
16716 {
16717 if (temp2)
16718 delete arg2;
16719 }
16720 return NULL;
16721 }
16722
16723
16724 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16725 PyObject *resultobj;
16726 wxString *arg1 = 0 ;
16727 wxString const &arg2_defvalue = wxPyART_OTHER ;
16728 wxString *arg2 = (wxString *) &arg2_defvalue ;
16729 wxSize const &arg3_defvalue = wxDefaultSize ;
16730 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16731 wxIcon result;
16732 bool temp1 = false ;
16733 bool temp2 = false ;
16734 wxSize temp3 ;
16735 PyObject * obj0 = 0 ;
16736 PyObject * obj1 = 0 ;
16737 PyObject * obj2 = 0 ;
16738 char *kwnames[] = {
16739 (char *) "id",(char *) "client",(char *) "size", NULL
16740 };
16741
16742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16743 {
16744 arg1 = wxString_in_helper(obj0);
16745 if (arg1 == NULL) SWIG_fail;
16746 temp1 = true;
16747 }
16748 if (obj1) {
16749 {
16750 arg2 = wxString_in_helper(obj1);
16751 if (arg2 == NULL) SWIG_fail;
16752 temp2 = true;
16753 }
16754 }
16755 if (obj2) {
16756 {
16757 arg3 = &temp3;
16758 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16759 }
16760 }
16761 {
16762 if (!wxPyCheckForApp()) SWIG_fail;
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 {
16770 wxIcon * resultptr;
16771 resultptr = new wxIcon((wxIcon &)(result));
16772 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16773 }
16774 {
16775 if (temp1)
16776 delete arg1;
16777 }
16778 {
16779 if (temp2)
16780 delete arg2;
16781 }
16782 return resultobj;
16783 fail:
16784 {
16785 if (temp1)
16786 delete arg1;
16787 }
16788 {
16789 if (temp2)
16790 delete arg2;
16791 }
16792 return NULL;
16793 }
16794
16795
16796 static PyObject *_wrap_ArtProvider_GetSizeHint(PyObject *, PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj;
16798 wxString *arg1 = 0 ;
16799 bool arg2 = (bool) false ;
16800 wxSize result;
16801 bool temp1 = false ;
16802 PyObject * obj0 = 0 ;
16803 PyObject * obj1 = 0 ;
16804 char *kwnames[] = {
16805 (char *) "client",(char *) "platform_dependent", NULL
16806 };
16807
16808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSizeHint",kwnames,&obj0,&obj1)) goto fail;
16809 {
16810 arg1 = wxString_in_helper(obj0);
16811 if (arg1 == NULL) SWIG_fail;
16812 temp1 = true;
16813 }
16814 if (obj1) {
16815 {
16816 arg2 = (bool)(SWIG_As_bool(obj1));
16817 if (SWIG_arg_fail(2)) SWIG_fail;
16818 }
16819 }
16820 {
16821 PyThreadState* __tstate = wxPyBeginAllowThreads();
16822 result = wxPyArtProvider::GetSizeHint((wxString const &)*arg1,arg2);
16823
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 {
16828 wxSize * resultptr;
16829 resultptr = new wxSize((wxSize &)(result));
16830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16831 }
16832 {
16833 if (temp1)
16834 delete arg1;
16835 }
16836 return resultobj;
16837 fail:
16838 {
16839 if (temp1)
16840 delete arg1;
16841 }
16842 return NULL;
16843 }
16844
16845
16846 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16847 PyObject *resultobj;
16848 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16849 PyObject * obj0 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self", NULL
16852 };
16853
16854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(1)) SWIG_fail;
16857 {
16858 PyThreadState* __tstate = wxPyBeginAllowThreads();
16859 wxPyArtProvider_Destroy(arg1);
16860
16861 wxPyEndAllowThreads(__tstate);
16862 if (PyErr_Occurred()) SWIG_fail;
16863 }
16864 Py_INCREF(Py_None); resultobj = Py_None;
16865 return resultobj;
16866 fail:
16867 return NULL;
16868 }
16869
16870
16871 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16872 PyObject *obj;
16873 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16874 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16875 Py_INCREF(obj);
16876 return Py_BuildValue((char *)"");
16877 }
16878 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj;
16880 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16881 PyObject * obj0 = 0 ;
16882 char *kwnames[] = {
16883 (char *) "self", NULL
16884 };
16885
16886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16888 if (SWIG_arg_fail(1)) SWIG_fail;
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 delete arg1;
16892
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 Py_INCREF(Py_None); resultobj = Py_None;
16897 return resultobj;
16898 fail:
16899 return NULL;
16900 }
16901
16902
16903 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16904 PyObject *resultobj;
16905 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16906 wxConfigBase *result;
16907 PyObject * obj0 = 0 ;
16908 char *kwnames[] = {
16909 (char *) "config", NULL
16910 };
16911
16912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16914 if (SWIG_arg_fail(1)) SWIG_fail;
16915 {
16916 PyThreadState* __tstate = wxPyBeginAllowThreads();
16917 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16918
16919 wxPyEndAllowThreads(__tstate);
16920 if (PyErr_Occurred()) SWIG_fail;
16921 }
16922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16923 return resultobj;
16924 fail:
16925 return NULL;
16926 }
16927
16928
16929 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16930 PyObject *resultobj;
16931 bool arg1 = (bool) true ;
16932 wxConfigBase *result;
16933 PyObject * obj0 = 0 ;
16934 char *kwnames[] = {
16935 (char *) "createOnDemand", NULL
16936 };
16937
16938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16939 if (obj0) {
16940 {
16941 arg1 = (bool)(SWIG_As_bool(obj0));
16942 if (SWIG_arg_fail(1)) SWIG_fail;
16943 }
16944 }
16945 {
16946 PyThreadState* __tstate = wxPyBeginAllowThreads();
16947 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16948
16949 wxPyEndAllowThreads(__tstate);
16950 if (PyErr_Occurred()) SWIG_fail;
16951 }
16952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16953 return resultobj;
16954 fail:
16955 return NULL;
16956 }
16957
16958
16959 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16960 PyObject *resultobj;
16961 wxConfigBase *result;
16962 char *kwnames[] = {
16963 NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16967 {
16968 PyThreadState* __tstate = wxPyBeginAllowThreads();
16969 result = (wxConfigBase *)wxConfigBase::Create();
16970
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj;
16983 char *kwnames[] = {
16984 NULL
16985 };
16986
16987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16988 {
16989 PyThreadState* __tstate = wxPyBeginAllowThreads();
16990 wxConfigBase::DontCreateOnDemand();
16991
16992 wxPyEndAllowThreads(__tstate);
16993 if (PyErr_Occurred()) SWIG_fail;
16994 }
16995 Py_INCREF(Py_None); resultobj = Py_None;
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj;
17004 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17005 wxString *arg2 = 0 ;
17006 bool temp2 = false ;
17007 PyObject * obj0 = 0 ;
17008 PyObject * obj1 = 0 ;
17009 char *kwnames[] = {
17010 (char *) "self",(char *) "path", NULL
17011 };
17012
17013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
17014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17015 if (SWIG_arg_fail(1)) SWIG_fail;
17016 {
17017 arg2 = wxString_in_helper(obj1);
17018 if (arg2 == NULL) SWIG_fail;
17019 temp2 = true;
17020 }
17021 {
17022 PyThreadState* __tstate = wxPyBeginAllowThreads();
17023 (arg1)->SetPath((wxString const &)*arg2);
17024
17025 wxPyEndAllowThreads(__tstate);
17026 if (PyErr_Occurred()) SWIG_fail;
17027 }
17028 Py_INCREF(Py_None); resultobj = Py_None;
17029 {
17030 if (temp2)
17031 delete arg2;
17032 }
17033 return resultobj;
17034 fail:
17035 {
17036 if (temp2)
17037 delete arg2;
17038 }
17039 return NULL;
17040 }
17041
17042
17043 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj;
17045 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17046 wxString *result;
17047 PyObject * obj0 = 0 ;
17048 char *kwnames[] = {
17049 (char *) "self", NULL
17050 };
17051
17052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
17053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17054 if (SWIG_arg_fail(1)) SWIG_fail;
17055 {
17056 PyThreadState* __tstate = wxPyBeginAllowThreads();
17057 {
17058 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17059 result = (wxString *) &_result_ref;
17060 }
17061
17062 wxPyEndAllowThreads(__tstate);
17063 if (PyErr_Occurred()) SWIG_fail;
17064 }
17065 {
17066 #if wxUSE_UNICODE
17067 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17068 #else
17069 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17070 #endif
17071 }
17072 return resultobj;
17073 fail:
17074 return NULL;
17075 }
17076
17077
17078 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17079 PyObject *resultobj;
17080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17081 PyObject *result;
17082 PyObject * obj0 = 0 ;
17083 char *kwnames[] = {
17084 (char *) "self", NULL
17085 };
17086
17087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17089 if (SWIG_arg_fail(1)) SWIG_fail;
17090 {
17091 PyThreadState* __tstate = wxPyBeginAllowThreads();
17092 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17093
17094 wxPyEndAllowThreads(__tstate);
17095 if (PyErr_Occurred()) SWIG_fail;
17096 }
17097 resultobj = result;
17098 return resultobj;
17099 fail:
17100 return NULL;
17101 }
17102
17103
17104 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17105 PyObject *resultobj;
17106 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17107 long arg2 ;
17108 PyObject *result;
17109 PyObject * obj0 = 0 ;
17110 PyObject * obj1 = 0 ;
17111 char *kwnames[] = {
17112 (char *) "self",(char *) "index", NULL
17113 };
17114
17115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17117 if (SWIG_arg_fail(1)) SWIG_fail;
17118 {
17119 arg2 = (long)(SWIG_As_long(obj1));
17120 if (SWIG_arg_fail(2)) SWIG_fail;
17121 }
17122 {
17123 PyThreadState* __tstate = wxPyBeginAllowThreads();
17124 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17125
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 resultobj = result;
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj;
17138 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17139 PyObject *result;
17140 PyObject * obj0 = 0 ;
17141 char *kwnames[] = {
17142 (char *) "self", NULL
17143 };
17144
17145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17147 if (SWIG_arg_fail(1)) SWIG_fail;
17148 {
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17151
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 resultobj = result;
17156 return resultobj;
17157 fail:
17158 return NULL;
17159 }
17160
17161
17162 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17163 PyObject *resultobj;
17164 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17165 long arg2 ;
17166 PyObject *result;
17167 PyObject * obj0 = 0 ;
17168 PyObject * obj1 = 0 ;
17169 char *kwnames[] = {
17170 (char *) "self",(char *) "index", NULL
17171 };
17172
17173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17175 if (SWIG_arg_fail(1)) SWIG_fail;
17176 {
17177 arg2 = (long)(SWIG_As_long(obj1));
17178 if (SWIG_arg_fail(2)) SWIG_fail;
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17183
17184 wxPyEndAllowThreads(__tstate);
17185 if (PyErr_Occurred()) SWIG_fail;
17186 }
17187 resultobj = result;
17188 return resultobj;
17189 fail:
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17197 bool arg2 = (bool) false ;
17198 size_t result;
17199 PyObject * obj0 = 0 ;
17200 PyObject * obj1 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "self",(char *) "recursive", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17207 if (SWIG_arg_fail(1)) SWIG_fail;
17208 if (obj1) {
17209 {
17210 arg2 = (bool)(SWIG_As_bool(obj1));
17211 if (SWIG_arg_fail(2)) SWIG_fail;
17212 }
17213 }
17214 {
17215 PyThreadState* __tstate = wxPyBeginAllowThreads();
17216 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17217
17218 wxPyEndAllowThreads(__tstate);
17219 if (PyErr_Occurred()) SWIG_fail;
17220 }
17221 {
17222 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17223 }
17224 return resultobj;
17225 fail:
17226 return NULL;
17227 }
17228
17229
17230 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(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_GetNumberOfGroups",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)->GetNumberOfGroups(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_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17267 PyObject *resultobj;
17268 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17269 wxString *arg2 = 0 ;
17270 bool result;
17271 bool temp2 = false ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 char *kwnames[] = {
17275 (char *) "self",(char *) "name", NULL
17276 };
17277
17278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17280 if (SWIG_arg_fail(1)) SWIG_fail;
17281 {
17282 arg2 = wxString_in_helper(obj1);
17283 if (arg2 == NULL) SWIG_fail;
17284 temp2 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17289
17290 wxPyEndAllowThreads(__tstate);
17291 if (PyErr_Occurred()) SWIG_fail;
17292 }
17293 {
17294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17295 }
17296 {
17297 if (temp2)
17298 delete arg2;
17299 }
17300 return resultobj;
17301 fail:
17302 {
17303 if (temp2)
17304 delete arg2;
17305 }
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj;
17312 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17313 wxString *arg2 = 0 ;
17314 bool result;
17315 bool temp2 = false ;
17316 PyObject * obj0 = 0 ;
17317 PyObject * obj1 = 0 ;
17318 char *kwnames[] = {
17319 (char *) "self",(char *) "name", NULL
17320 };
17321
17322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17324 if (SWIG_arg_fail(1)) SWIG_fail;
17325 {
17326 arg2 = wxString_in_helper(obj1);
17327 if (arg2 == NULL) SWIG_fail;
17328 temp2 = true;
17329 }
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17333
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 {
17341 if (temp2)
17342 delete arg2;
17343 }
17344 return resultobj;
17345 fail:
17346 {
17347 if (temp2)
17348 delete arg2;
17349 }
17350 return NULL;
17351 }
17352
17353
17354 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17355 PyObject *resultobj;
17356 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17357 wxString *arg2 = 0 ;
17358 bool result;
17359 bool temp2 = false ;
17360 PyObject * obj0 = 0 ;
17361 PyObject * obj1 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self",(char *) "name", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17368 if (SWIG_arg_fail(1)) SWIG_fail;
17369 {
17370 arg2 = wxString_in_helper(obj1);
17371 if (arg2 == NULL) SWIG_fail;
17372 temp2 = true;
17373 }
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17377
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17383 }
17384 {
17385 if (temp2)
17386 delete arg2;
17387 }
17388 return resultobj;
17389 fail:
17390 {
17391 if (temp2)
17392 delete arg2;
17393 }
17394 return NULL;
17395 }
17396
17397
17398 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17399 PyObject *resultobj;
17400 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17401 wxString *arg2 = 0 ;
17402 wxConfigBase::EntryType result;
17403 bool temp2 = false ;
17404 PyObject * obj0 = 0 ;
17405 PyObject * obj1 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self",(char *) "name", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 arg2 = wxString_in_helper(obj1);
17415 if (arg2 == NULL) SWIG_fail;
17416 temp2 = true;
17417 }
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 resultobj = SWIG_From_int((result));
17426 {
17427 if (temp2)
17428 delete arg2;
17429 }
17430 return resultobj;
17431 fail:
17432 {
17433 if (temp2)
17434 delete arg2;
17435 }
17436 return NULL;
17437 }
17438
17439
17440 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj;
17442 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17443 wxString *arg2 = 0 ;
17444 wxString const &arg3_defvalue = wxPyEmptyString ;
17445 wxString *arg3 = (wxString *) &arg3_defvalue ;
17446 wxString result;
17447 bool temp2 = false ;
17448 bool temp3 = false ;
17449 PyObject * obj0 = 0 ;
17450 PyObject * obj1 = 0 ;
17451 PyObject * obj2 = 0 ;
17452 char *kwnames[] = {
17453 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17454 };
17455
17456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17458 if (SWIG_arg_fail(1)) SWIG_fail;
17459 {
17460 arg2 = wxString_in_helper(obj1);
17461 if (arg2 == NULL) SWIG_fail;
17462 temp2 = true;
17463 }
17464 if (obj2) {
17465 {
17466 arg3 = wxString_in_helper(obj2);
17467 if (arg3 == NULL) SWIG_fail;
17468 temp3 = true;
17469 }
17470 }
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17474
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 #if wxUSE_UNICODE
17480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17481 #else
17482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17483 #endif
17484 }
17485 {
17486 if (temp2)
17487 delete arg2;
17488 }
17489 {
17490 if (temp3)
17491 delete arg3;
17492 }
17493 return resultobj;
17494 fail:
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 {
17500 if (temp3)
17501 delete arg3;
17502 }
17503 return NULL;
17504 }
17505
17506
17507 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17508 PyObject *resultobj;
17509 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17510 wxString *arg2 = 0 ;
17511 long arg3 = (long) 0 ;
17512 long result;
17513 bool temp2 = false ;
17514 PyObject * obj0 = 0 ;
17515 PyObject * obj1 = 0 ;
17516 PyObject * obj2 = 0 ;
17517 char *kwnames[] = {
17518 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17519 };
17520
17521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17523 if (SWIG_arg_fail(1)) SWIG_fail;
17524 {
17525 arg2 = wxString_in_helper(obj1);
17526 if (arg2 == NULL) SWIG_fail;
17527 temp2 = true;
17528 }
17529 if (obj2) {
17530 {
17531 arg3 = (long)(SWIG_As_long(obj2));
17532 if (SWIG_arg_fail(3)) SWIG_fail;
17533 }
17534 }
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17538
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = SWIG_From_long((long)(result));
17544 }
17545 {
17546 if (temp2)
17547 delete arg2;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 return NULL;
17556 }
17557
17558
17559 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj;
17561 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17562 wxString *arg2 = 0 ;
17563 double arg3 = (double) 0.0 ;
17564 double result;
17565 bool temp2 = false ;
17566 PyObject * obj0 = 0 ;
17567 PyObject * obj1 = 0 ;
17568 PyObject * obj2 = 0 ;
17569 char *kwnames[] = {
17570 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17571 };
17572
17573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17575 if (SWIG_arg_fail(1)) SWIG_fail;
17576 {
17577 arg2 = wxString_in_helper(obj1);
17578 if (arg2 == NULL) SWIG_fail;
17579 temp2 = true;
17580 }
17581 if (obj2) {
17582 {
17583 arg3 = (double)(SWIG_As_double(obj2));
17584 if (SWIG_arg_fail(3)) SWIG_fail;
17585 }
17586 }
17587 {
17588 PyThreadState* __tstate = wxPyBeginAllowThreads();
17589 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17590
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 {
17595 resultobj = SWIG_From_double((double)(result));
17596 }
17597 {
17598 if (temp2)
17599 delete arg2;
17600 }
17601 return resultobj;
17602 fail:
17603 {
17604 if (temp2)
17605 delete arg2;
17606 }
17607 return NULL;
17608 }
17609
17610
17611 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17612 PyObject *resultobj;
17613 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17614 wxString *arg2 = 0 ;
17615 bool arg3 = (bool) false ;
17616 bool result;
17617 bool temp2 = false ;
17618 PyObject * obj0 = 0 ;
17619 PyObject * obj1 = 0 ;
17620 PyObject * obj2 = 0 ;
17621 char *kwnames[] = {
17622 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17623 };
17624
17625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17627 if (SWIG_arg_fail(1)) SWIG_fail;
17628 {
17629 arg2 = wxString_in_helper(obj1);
17630 if (arg2 == NULL) SWIG_fail;
17631 temp2 = true;
17632 }
17633 if (obj2) {
17634 {
17635 arg3 = (bool)(SWIG_As_bool(obj2));
17636 if (SWIG_arg_fail(3)) SWIG_fail;
17637 }
17638 }
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17642
17643 wxPyEndAllowThreads(__tstate);
17644 if (PyErr_Occurred()) SWIG_fail;
17645 }
17646 {
17647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17648 }
17649 {
17650 if (temp2)
17651 delete arg2;
17652 }
17653 return resultobj;
17654 fail:
17655 {
17656 if (temp2)
17657 delete arg2;
17658 }
17659 return NULL;
17660 }
17661
17662
17663 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17664 PyObject *resultobj;
17665 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17666 wxString *arg2 = 0 ;
17667 wxString *arg3 = 0 ;
17668 bool result;
17669 bool temp2 = false ;
17670 bool temp3 = false ;
17671 PyObject * obj0 = 0 ;
17672 PyObject * obj1 = 0 ;
17673 PyObject * obj2 = 0 ;
17674 char *kwnames[] = {
17675 (char *) "self",(char *) "key",(char *) "value", NULL
17676 };
17677
17678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17680 if (SWIG_arg_fail(1)) SWIG_fail;
17681 {
17682 arg2 = wxString_in_helper(obj1);
17683 if (arg2 == NULL) SWIG_fail;
17684 temp2 = true;
17685 }
17686 {
17687 arg3 = wxString_in_helper(obj2);
17688 if (arg3 == NULL) SWIG_fail;
17689 temp3 = true;
17690 }
17691 {
17692 PyThreadState* __tstate = wxPyBeginAllowThreads();
17693 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17694
17695 wxPyEndAllowThreads(__tstate);
17696 if (PyErr_Occurred()) SWIG_fail;
17697 }
17698 {
17699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17700 }
17701 {
17702 if (temp2)
17703 delete arg2;
17704 }
17705 {
17706 if (temp3)
17707 delete arg3;
17708 }
17709 return resultobj;
17710 fail:
17711 {
17712 if (temp2)
17713 delete arg2;
17714 }
17715 {
17716 if (temp3)
17717 delete arg3;
17718 }
17719 return NULL;
17720 }
17721
17722
17723 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17724 PyObject *resultobj;
17725 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17726 wxString *arg2 = 0 ;
17727 long arg3 ;
17728 bool result;
17729 bool temp2 = false ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 PyObject * obj2 = 0 ;
17733 char *kwnames[] = {
17734 (char *) "self",(char *) "key",(char *) "value", NULL
17735 };
17736
17737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17739 if (SWIG_arg_fail(1)) SWIG_fail;
17740 {
17741 arg2 = wxString_in_helper(obj1);
17742 if (arg2 == NULL) SWIG_fail;
17743 temp2 = true;
17744 }
17745 {
17746 arg3 = (long)(SWIG_As_long(obj2));
17747 if (SWIG_arg_fail(3)) SWIG_fail;
17748 }
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17752
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17758 }
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return resultobj;
17764 fail:
17765 {
17766 if (temp2)
17767 delete arg2;
17768 }
17769 return NULL;
17770 }
17771
17772
17773 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17774 PyObject *resultobj;
17775 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17776 wxString *arg2 = 0 ;
17777 double arg3 ;
17778 bool result;
17779 bool temp2 = false ;
17780 PyObject * obj0 = 0 ;
17781 PyObject * obj1 = 0 ;
17782 PyObject * obj2 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self",(char *) "key",(char *) "value", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 arg2 = wxString_in_helper(obj1);
17792 if (arg2 == NULL) SWIG_fail;
17793 temp2 = true;
17794 }
17795 {
17796 arg3 = (double)(SWIG_As_double(obj2));
17797 if (SWIG_arg_fail(3)) SWIG_fail;
17798 }
17799 {
17800 PyThreadState* __tstate = wxPyBeginAllowThreads();
17801 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17802
17803 wxPyEndAllowThreads(__tstate);
17804 if (PyErr_Occurred()) SWIG_fail;
17805 }
17806 {
17807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17808 }
17809 {
17810 if (temp2)
17811 delete arg2;
17812 }
17813 return resultobj;
17814 fail:
17815 {
17816 if (temp2)
17817 delete arg2;
17818 }
17819 return NULL;
17820 }
17821
17822
17823 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj;
17825 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17826 wxString *arg2 = 0 ;
17827 bool arg3 ;
17828 bool result;
17829 bool temp2 = false ;
17830 PyObject * obj0 = 0 ;
17831 PyObject * obj1 = 0 ;
17832 PyObject * obj2 = 0 ;
17833 char *kwnames[] = {
17834 (char *) "self",(char *) "key",(char *) "value", NULL
17835 };
17836
17837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17839 if (SWIG_arg_fail(1)) SWIG_fail;
17840 {
17841 arg2 = wxString_in_helper(obj1);
17842 if (arg2 == NULL) SWIG_fail;
17843 temp2 = true;
17844 }
17845 {
17846 arg3 = (bool)(SWIG_As_bool(obj2));
17847 if (SWIG_arg_fail(3)) SWIG_fail;
17848 }
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17852
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 {
17857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17858 }
17859 {
17860 if (temp2)
17861 delete arg2;
17862 }
17863 return resultobj;
17864 fail:
17865 {
17866 if (temp2)
17867 delete arg2;
17868 }
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj;
17875 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17876 bool arg2 = (bool) false ;
17877 bool result;
17878 PyObject * obj0 = 0 ;
17879 PyObject * obj1 = 0 ;
17880 char *kwnames[] = {
17881 (char *) "self",(char *) "currentOnly", NULL
17882 };
17883
17884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17886 if (SWIG_arg_fail(1)) SWIG_fail;
17887 if (obj1) {
17888 {
17889 arg2 = (bool)(SWIG_As_bool(obj1));
17890 if (SWIG_arg_fail(2)) SWIG_fail;
17891 }
17892 }
17893 {
17894 PyThreadState* __tstate = wxPyBeginAllowThreads();
17895 result = (bool)(arg1)->Flush(arg2);
17896
17897 wxPyEndAllowThreads(__tstate);
17898 if (PyErr_Occurred()) SWIG_fail;
17899 }
17900 {
17901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17902 }
17903 return resultobj;
17904 fail:
17905 return NULL;
17906 }
17907
17908
17909 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17910 PyObject *resultobj;
17911 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17912 wxString *arg2 = 0 ;
17913 wxString *arg3 = 0 ;
17914 bool result;
17915 bool temp2 = false ;
17916 bool temp3 = false ;
17917 PyObject * obj0 = 0 ;
17918 PyObject * obj1 = 0 ;
17919 PyObject * obj2 = 0 ;
17920 char *kwnames[] = {
17921 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17922 };
17923
17924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17926 if (SWIG_arg_fail(1)) SWIG_fail;
17927 {
17928 arg2 = wxString_in_helper(obj1);
17929 if (arg2 == NULL) SWIG_fail;
17930 temp2 = true;
17931 }
17932 {
17933 arg3 = wxString_in_helper(obj2);
17934 if (arg3 == NULL) SWIG_fail;
17935 temp3 = true;
17936 }
17937 {
17938 PyThreadState* __tstate = wxPyBeginAllowThreads();
17939 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17940
17941 wxPyEndAllowThreads(__tstate);
17942 if (PyErr_Occurred()) SWIG_fail;
17943 }
17944 {
17945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17946 }
17947 {
17948 if (temp2)
17949 delete arg2;
17950 }
17951 {
17952 if (temp3)
17953 delete arg3;
17954 }
17955 return resultobj;
17956 fail:
17957 {
17958 if (temp2)
17959 delete arg2;
17960 }
17961 {
17962 if (temp3)
17963 delete arg3;
17964 }
17965 return NULL;
17966 }
17967
17968
17969 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj;
17971 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17972 wxString *arg2 = 0 ;
17973 wxString *arg3 = 0 ;
17974 bool result;
17975 bool temp2 = false ;
17976 bool temp3 = false ;
17977 PyObject * obj0 = 0 ;
17978 PyObject * obj1 = 0 ;
17979 PyObject * obj2 = 0 ;
17980 char *kwnames[] = {
17981 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17982 };
17983
17984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17986 if (SWIG_arg_fail(1)) SWIG_fail;
17987 {
17988 arg2 = wxString_in_helper(obj1);
17989 if (arg2 == NULL) SWIG_fail;
17990 temp2 = true;
17991 }
17992 {
17993 arg3 = wxString_in_helper(obj2);
17994 if (arg3 == NULL) SWIG_fail;
17995 temp3 = true;
17996 }
17997 {
17998 PyThreadState* __tstate = wxPyBeginAllowThreads();
17999 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
18000
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 {
18005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18006 }
18007 {
18008 if (temp2)
18009 delete arg2;
18010 }
18011 {
18012 if (temp3)
18013 delete arg3;
18014 }
18015 return resultobj;
18016 fail:
18017 {
18018 if (temp2)
18019 delete arg2;
18020 }
18021 {
18022 if (temp3)
18023 delete arg3;
18024 }
18025 return NULL;
18026 }
18027
18028
18029 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
18030 PyObject *resultobj;
18031 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18032 wxString *arg2 = 0 ;
18033 bool arg3 = (bool) true ;
18034 bool result;
18035 bool temp2 = false ;
18036 PyObject * obj0 = 0 ;
18037 PyObject * obj1 = 0 ;
18038 PyObject * obj2 = 0 ;
18039 char *kwnames[] = {
18040 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
18041 };
18042
18043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
18044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18045 if (SWIG_arg_fail(1)) SWIG_fail;
18046 {
18047 arg2 = wxString_in_helper(obj1);
18048 if (arg2 == NULL) SWIG_fail;
18049 temp2 = true;
18050 }
18051 if (obj2) {
18052 {
18053 arg3 = (bool)(SWIG_As_bool(obj2));
18054 if (SWIG_arg_fail(3)) SWIG_fail;
18055 }
18056 }
18057 {
18058 PyThreadState* __tstate = wxPyBeginAllowThreads();
18059 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18060
18061 wxPyEndAllowThreads(__tstate);
18062 if (PyErr_Occurred()) SWIG_fail;
18063 }
18064 {
18065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18066 }
18067 {
18068 if (temp2)
18069 delete arg2;
18070 }
18071 return resultobj;
18072 fail:
18073 {
18074 if (temp2)
18075 delete arg2;
18076 }
18077 return NULL;
18078 }
18079
18080
18081 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj;
18083 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18084 wxString *arg2 = 0 ;
18085 bool result;
18086 bool temp2 = false ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 char *kwnames[] = {
18090 (char *) "self",(char *) "key", NULL
18091 };
18092
18093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18095 if (SWIG_arg_fail(1)) SWIG_fail;
18096 {
18097 arg2 = wxString_in_helper(obj1);
18098 if (arg2 == NULL) SWIG_fail;
18099 temp2 = true;
18100 }
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 {
18109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18110 }
18111 {
18112 if (temp2)
18113 delete arg2;
18114 }
18115 return resultobj;
18116 fail:
18117 {
18118 if (temp2)
18119 delete arg2;
18120 }
18121 return NULL;
18122 }
18123
18124
18125 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18126 PyObject *resultobj;
18127 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18128 bool result;
18129 PyObject * obj0 = 0 ;
18130 char *kwnames[] = {
18131 (char *) "self", NULL
18132 };
18133
18134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18136 if (SWIG_arg_fail(1)) SWIG_fail;
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (bool)(arg1)->DeleteAll();
18140
18141 wxPyEndAllowThreads(__tstate);
18142 if (PyErr_Occurred()) SWIG_fail;
18143 }
18144 {
18145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18146 }
18147 return resultobj;
18148 fail:
18149 return NULL;
18150 }
18151
18152
18153 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18154 PyObject *resultobj;
18155 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18156 bool arg2 = (bool) true ;
18157 PyObject * obj0 = 0 ;
18158 PyObject * obj1 = 0 ;
18159 char *kwnames[] = {
18160 (char *) "self",(char *) "doIt", NULL
18161 };
18162
18163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18165 if (SWIG_arg_fail(1)) SWIG_fail;
18166 if (obj1) {
18167 {
18168 arg2 = (bool)(SWIG_As_bool(obj1));
18169 if (SWIG_arg_fail(2)) SWIG_fail;
18170 }
18171 }
18172 {
18173 PyThreadState* __tstate = wxPyBeginAllowThreads();
18174 (arg1)->SetExpandEnvVars(arg2);
18175
18176 wxPyEndAllowThreads(__tstate);
18177 if (PyErr_Occurred()) SWIG_fail;
18178 }
18179 Py_INCREF(Py_None); resultobj = Py_None;
18180 return resultobj;
18181 fail:
18182 return NULL;
18183 }
18184
18185
18186 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18187 PyObject *resultobj;
18188 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18189 bool result;
18190 PyObject * obj0 = 0 ;
18191 char *kwnames[] = {
18192 (char *) "self", NULL
18193 };
18194
18195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18197 if (SWIG_arg_fail(1)) SWIG_fail;
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18201
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 {
18206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18207 }
18208 return resultobj;
18209 fail:
18210 return NULL;
18211 }
18212
18213
18214 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18215 PyObject *resultobj;
18216 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18217 bool arg2 = (bool) true ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char *kwnames[] = {
18221 (char *) "self",(char *) "doIt", NULL
18222 };
18223
18224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18226 if (SWIG_arg_fail(1)) SWIG_fail;
18227 if (obj1) {
18228 {
18229 arg2 = (bool)(SWIG_As_bool(obj1));
18230 if (SWIG_arg_fail(2)) SWIG_fail;
18231 }
18232 }
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 (arg1)->SetRecordDefaults(arg2);
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 Py_INCREF(Py_None); resultobj = Py_None;
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj;
18249 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18250 bool result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18262
18263 wxPyEndAllowThreads(__tstate);
18264 if (PyErr_Occurred()) SWIG_fail;
18265 }
18266 {
18267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18268 }
18269 return resultobj;
18270 fail:
18271 return NULL;
18272 }
18273
18274
18275 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18276 PyObject *resultobj;
18277 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18278 wxString *arg2 = 0 ;
18279 wxString result;
18280 bool temp2 = false ;
18281 PyObject * obj0 = 0 ;
18282 PyObject * obj1 = 0 ;
18283 char *kwnames[] = {
18284 (char *) "self",(char *) "str", NULL
18285 };
18286
18287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18289 if (SWIG_arg_fail(1)) SWIG_fail;
18290 {
18291 arg2 = wxString_in_helper(obj1);
18292 if (arg2 == NULL) SWIG_fail;
18293 temp2 = true;
18294 }
18295 {
18296 PyThreadState* __tstate = wxPyBeginAllowThreads();
18297 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18298
18299 wxPyEndAllowThreads(__tstate);
18300 if (PyErr_Occurred()) SWIG_fail;
18301 }
18302 {
18303 #if wxUSE_UNICODE
18304 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18305 #else
18306 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18307 #endif
18308 }
18309 {
18310 if (temp2)
18311 delete arg2;
18312 }
18313 return resultobj;
18314 fail:
18315 {
18316 if (temp2)
18317 delete arg2;
18318 }
18319 return NULL;
18320 }
18321
18322
18323 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18324 PyObject *resultobj;
18325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18326 wxString result;
18327 PyObject * obj0 = 0 ;
18328 char *kwnames[] = {
18329 (char *) "self", NULL
18330 };
18331
18332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18334 if (SWIG_arg_fail(1)) SWIG_fail;
18335 {
18336 PyThreadState* __tstate = wxPyBeginAllowThreads();
18337 result = ((wxConfigBase const *)arg1)->GetAppName();
18338
18339 wxPyEndAllowThreads(__tstate);
18340 if (PyErr_Occurred()) SWIG_fail;
18341 }
18342 {
18343 #if wxUSE_UNICODE
18344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18345 #else
18346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18347 #endif
18348 }
18349 return resultobj;
18350 fail:
18351 return NULL;
18352 }
18353
18354
18355 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18356 PyObject *resultobj;
18357 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18358 wxString result;
18359 PyObject * obj0 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 PyThreadState* __tstate = wxPyBeginAllowThreads();
18369 result = ((wxConfigBase const *)arg1)->GetVendorName();
18370
18371 wxPyEndAllowThreads(__tstate);
18372 if (PyErr_Occurred()) SWIG_fail;
18373 }
18374 {
18375 #if wxUSE_UNICODE
18376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18377 #else
18378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18379 #endif
18380 }
18381 return resultobj;
18382 fail:
18383 return NULL;
18384 }
18385
18386
18387 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18388 PyObject *resultobj;
18389 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18390 wxString *arg2 = 0 ;
18391 bool temp2 = false ;
18392 PyObject * obj0 = 0 ;
18393 PyObject * obj1 = 0 ;
18394 char *kwnames[] = {
18395 (char *) "self",(char *) "appName", NULL
18396 };
18397
18398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18400 if (SWIG_arg_fail(1)) SWIG_fail;
18401 {
18402 arg2 = wxString_in_helper(obj1);
18403 if (arg2 == NULL) SWIG_fail;
18404 temp2 = true;
18405 }
18406 {
18407 PyThreadState* __tstate = wxPyBeginAllowThreads();
18408 (arg1)->SetAppName((wxString const &)*arg2);
18409
18410 wxPyEndAllowThreads(__tstate);
18411 if (PyErr_Occurred()) SWIG_fail;
18412 }
18413 Py_INCREF(Py_None); resultobj = Py_None;
18414 {
18415 if (temp2)
18416 delete arg2;
18417 }
18418 return resultobj;
18419 fail:
18420 {
18421 if (temp2)
18422 delete arg2;
18423 }
18424 return NULL;
18425 }
18426
18427
18428 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18429 PyObject *resultobj;
18430 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18431 wxString *arg2 = 0 ;
18432 bool temp2 = false ;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 char *kwnames[] = {
18436 (char *) "self",(char *) "vendorName", NULL
18437 };
18438
18439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18441 if (SWIG_arg_fail(1)) SWIG_fail;
18442 {
18443 arg2 = wxString_in_helper(obj1);
18444 if (arg2 == NULL) SWIG_fail;
18445 temp2 = true;
18446 }
18447 {
18448 PyThreadState* __tstate = wxPyBeginAllowThreads();
18449 (arg1)->SetVendorName((wxString const &)*arg2);
18450
18451 wxPyEndAllowThreads(__tstate);
18452 if (PyErr_Occurred()) SWIG_fail;
18453 }
18454 Py_INCREF(Py_None); resultobj = Py_None;
18455 {
18456 if (temp2)
18457 delete arg2;
18458 }
18459 return resultobj;
18460 fail:
18461 {
18462 if (temp2)
18463 delete arg2;
18464 }
18465 return NULL;
18466 }
18467
18468
18469 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18470 PyObject *resultobj;
18471 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18472 long arg2 ;
18473 PyObject * obj0 = 0 ;
18474 PyObject * obj1 = 0 ;
18475 char *kwnames[] = {
18476 (char *) "self",(char *) "style", NULL
18477 };
18478
18479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18481 if (SWIG_arg_fail(1)) SWIG_fail;
18482 {
18483 arg2 = (long)(SWIG_As_long(obj1));
18484 if (SWIG_arg_fail(2)) SWIG_fail;
18485 }
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 (arg1)->SetStyle(arg2);
18489
18490 wxPyEndAllowThreads(__tstate);
18491 if (PyErr_Occurred()) SWIG_fail;
18492 }
18493 Py_INCREF(Py_None); resultobj = Py_None;
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18501 PyObject *resultobj;
18502 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18503 long result;
18504 PyObject * obj0 = 0 ;
18505 char *kwnames[] = {
18506 (char *) "self", NULL
18507 };
18508
18509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18511 if (SWIG_arg_fail(1)) SWIG_fail;
18512 {
18513 PyThreadState* __tstate = wxPyBeginAllowThreads();
18514 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18515
18516 wxPyEndAllowThreads(__tstate);
18517 if (PyErr_Occurred()) SWIG_fail;
18518 }
18519 {
18520 resultobj = SWIG_From_long((long)(result));
18521 }
18522 return resultobj;
18523 fail:
18524 return NULL;
18525 }
18526
18527
18528 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18529 PyObject *obj;
18530 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18531 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18532 Py_INCREF(obj);
18533 return Py_BuildValue((char *)"");
18534 }
18535 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18536 PyObject *resultobj;
18537 wxString const &arg1_defvalue = wxPyEmptyString ;
18538 wxString *arg1 = (wxString *) &arg1_defvalue ;
18539 wxString const &arg2_defvalue = wxPyEmptyString ;
18540 wxString *arg2 = (wxString *) &arg2_defvalue ;
18541 wxString const &arg3_defvalue = wxPyEmptyString ;
18542 wxString *arg3 = (wxString *) &arg3_defvalue ;
18543 wxString const &arg4_defvalue = wxPyEmptyString ;
18544 wxString *arg4 = (wxString *) &arg4_defvalue ;
18545 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18546 wxConfig *result;
18547 bool temp1 = false ;
18548 bool temp2 = false ;
18549 bool temp3 = false ;
18550 bool temp4 = false ;
18551 PyObject * obj0 = 0 ;
18552 PyObject * obj1 = 0 ;
18553 PyObject * obj2 = 0 ;
18554 PyObject * obj3 = 0 ;
18555 PyObject * obj4 = 0 ;
18556 char *kwnames[] = {
18557 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18558 };
18559
18560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18561 if (obj0) {
18562 {
18563 arg1 = wxString_in_helper(obj0);
18564 if (arg1 == NULL) SWIG_fail;
18565 temp1 = true;
18566 }
18567 }
18568 if (obj1) {
18569 {
18570 arg2 = wxString_in_helper(obj1);
18571 if (arg2 == NULL) SWIG_fail;
18572 temp2 = true;
18573 }
18574 }
18575 if (obj2) {
18576 {
18577 arg3 = wxString_in_helper(obj2);
18578 if (arg3 == NULL) SWIG_fail;
18579 temp3 = true;
18580 }
18581 }
18582 if (obj3) {
18583 {
18584 arg4 = wxString_in_helper(obj3);
18585 if (arg4 == NULL) SWIG_fail;
18586 temp4 = true;
18587 }
18588 }
18589 if (obj4) {
18590 {
18591 arg5 = (long)(SWIG_As_long(obj4));
18592 if (SWIG_arg_fail(5)) SWIG_fail;
18593 }
18594 }
18595 {
18596 PyThreadState* __tstate = wxPyBeginAllowThreads();
18597 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18598
18599 wxPyEndAllowThreads(__tstate);
18600 if (PyErr_Occurred()) SWIG_fail;
18601 }
18602 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18603 {
18604 if (temp1)
18605 delete arg1;
18606 }
18607 {
18608 if (temp2)
18609 delete arg2;
18610 }
18611 {
18612 if (temp3)
18613 delete arg3;
18614 }
18615 {
18616 if (temp4)
18617 delete arg4;
18618 }
18619 return resultobj;
18620 fail:
18621 {
18622 if (temp1)
18623 delete arg1;
18624 }
18625 {
18626 if (temp2)
18627 delete arg2;
18628 }
18629 {
18630 if (temp3)
18631 delete arg3;
18632 }
18633 {
18634 if (temp4)
18635 delete arg4;
18636 }
18637 return NULL;
18638 }
18639
18640
18641 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18642 PyObject *resultobj;
18643 wxConfig *arg1 = (wxConfig *) 0 ;
18644 PyObject * obj0 = 0 ;
18645 char *kwnames[] = {
18646 (char *) "self", NULL
18647 };
18648
18649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18651 if (SWIG_arg_fail(1)) SWIG_fail;
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 delete arg1;
18655
18656 wxPyEndAllowThreads(__tstate);
18657 if (PyErr_Occurred()) SWIG_fail;
18658 }
18659 Py_INCREF(Py_None); resultobj = Py_None;
18660 return resultobj;
18661 fail:
18662 return NULL;
18663 }
18664
18665
18666 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18667 PyObject *obj;
18668 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18669 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18670 Py_INCREF(obj);
18671 return Py_BuildValue((char *)"");
18672 }
18673 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj;
18675 wxString const &arg1_defvalue = wxPyEmptyString ;
18676 wxString *arg1 = (wxString *) &arg1_defvalue ;
18677 wxString const &arg2_defvalue = wxPyEmptyString ;
18678 wxString *arg2 = (wxString *) &arg2_defvalue ;
18679 wxString const &arg3_defvalue = wxPyEmptyString ;
18680 wxString *arg3 = (wxString *) &arg3_defvalue ;
18681 wxString const &arg4_defvalue = wxPyEmptyString ;
18682 wxString *arg4 = (wxString *) &arg4_defvalue ;
18683 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18684 wxFileConfig *result;
18685 bool temp1 = false ;
18686 bool temp2 = false ;
18687 bool temp3 = false ;
18688 bool temp4 = false ;
18689 PyObject * obj0 = 0 ;
18690 PyObject * obj1 = 0 ;
18691 PyObject * obj2 = 0 ;
18692 PyObject * obj3 = 0 ;
18693 PyObject * obj4 = 0 ;
18694 char *kwnames[] = {
18695 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18696 };
18697
18698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18699 if (obj0) {
18700 {
18701 arg1 = wxString_in_helper(obj0);
18702 if (arg1 == NULL) SWIG_fail;
18703 temp1 = true;
18704 }
18705 }
18706 if (obj1) {
18707 {
18708 arg2 = wxString_in_helper(obj1);
18709 if (arg2 == NULL) SWIG_fail;
18710 temp2 = true;
18711 }
18712 }
18713 if (obj2) {
18714 {
18715 arg3 = wxString_in_helper(obj2);
18716 if (arg3 == NULL) SWIG_fail;
18717 temp3 = true;
18718 }
18719 }
18720 if (obj3) {
18721 {
18722 arg4 = wxString_in_helper(obj3);
18723 if (arg4 == NULL) SWIG_fail;
18724 temp4 = true;
18725 }
18726 }
18727 if (obj4) {
18728 {
18729 arg5 = (long)(SWIG_As_long(obj4));
18730 if (SWIG_arg_fail(5)) SWIG_fail;
18731 }
18732 }
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18736
18737 wxPyEndAllowThreads(__tstate);
18738 if (PyErr_Occurred()) SWIG_fail;
18739 }
18740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18741 {
18742 if (temp1)
18743 delete arg1;
18744 }
18745 {
18746 if (temp2)
18747 delete arg2;
18748 }
18749 {
18750 if (temp3)
18751 delete arg3;
18752 }
18753 {
18754 if (temp4)
18755 delete arg4;
18756 }
18757 return resultobj;
18758 fail:
18759 {
18760 if (temp1)
18761 delete arg1;
18762 }
18763 {
18764 if (temp2)
18765 delete arg2;
18766 }
18767 {
18768 if (temp3)
18769 delete arg3;
18770 }
18771 {
18772 if (temp4)
18773 delete arg4;
18774 }
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18782 PyObject * obj0 = 0 ;
18783 char *kwnames[] = {
18784 (char *) "self", NULL
18785 };
18786
18787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18789 if (SWIG_arg_fail(1)) SWIG_fail;
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 delete arg1;
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 Py_INCREF(Py_None); resultobj = Py_None;
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18805 PyObject *obj;
18806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18807 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18808 Py_INCREF(obj);
18809 return Py_BuildValue((char *)"");
18810 }
18811 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18812 PyObject *resultobj;
18813 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18814 wxString *arg2 = 0 ;
18815 wxConfigPathChanger *result;
18816 bool temp2 = false ;
18817 PyObject * obj0 = 0 ;
18818 PyObject * obj1 = 0 ;
18819 char *kwnames[] = {
18820 (char *) "config",(char *) "entry", NULL
18821 };
18822
18823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18825 if (SWIG_arg_fail(1)) SWIG_fail;
18826 {
18827 arg2 = wxString_in_helper(obj1);
18828 if (arg2 == NULL) SWIG_fail;
18829 temp2 = true;
18830 }
18831 {
18832 PyThreadState* __tstate = wxPyBeginAllowThreads();
18833 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18834
18835 wxPyEndAllowThreads(__tstate);
18836 if (PyErr_Occurred()) SWIG_fail;
18837 }
18838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18839 {
18840 if (temp2)
18841 delete arg2;
18842 }
18843 return resultobj;
18844 fail:
18845 {
18846 if (temp2)
18847 delete arg2;
18848 }
18849 return NULL;
18850 }
18851
18852
18853 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18854 PyObject *resultobj;
18855 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18856 PyObject * obj0 = 0 ;
18857 char *kwnames[] = {
18858 (char *) "self", NULL
18859 };
18860
18861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18863 if (SWIG_arg_fail(1)) SWIG_fail;
18864 {
18865 PyThreadState* __tstate = wxPyBeginAllowThreads();
18866 delete arg1;
18867
18868 wxPyEndAllowThreads(__tstate);
18869 if (PyErr_Occurred()) SWIG_fail;
18870 }
18871 Py_INCREF(Py_None); resultobj = Py_None;
18872 return resultobj;
18873 fail:
18874 return NULL;
18875 }
18876
18877
18878 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18879 PyObject *resultobj;
18880 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18881 wxString *result;
18882 PyObject * obj0 = 0 ;
18883 char *kwnames[] = {
18884 (char *) "self", NULL
18885 };
18886
18887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18889 if (SWIG_arg_fail(1)) SWIG_fail;
18890 {
18891 PyThreadState* __tstate = wxPyBeginAllowThreads();
18892 {
18893 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18894 result = (wxString *) &_result_ref;
18895 }
18896
18897 wxPyEndAllowThreads(__tstate);
18898 if (PyErr_Occurred()) SWIG_fail;
18899 }
18900 {
18901 #if wxUSE_UNICODE
18902 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18903 #else
18904 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18905 #endif
18906 }
18907 return resultobj;
18908 fail:
18909 return NULL;
18910 }
18911
18912
18913 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18914 PyObject *obj;
18915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18916 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18917 Py_INCREF(obj);
18918 return Py_BuildValue((char *)"");
18919 }
18920 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18921 PyObject *resultobj;
18922 wxString *arg1 = 0 ;
18923 wxString result;
18924 bool temp1 = false ;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "sz", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18931 {
18932 arg1 = wxString_in_helper(obj0);
18933 if (arg1 == NULL) SWIG_fail;
18934 temp1 = true;
18935 }
18936 {
18937 PyThreadState* __tstate = wxPyBeginAllowThreads();
18938 result = wxExpandEnvVars((wxString const &)*arg1);
18939
18940 wxPyEndAllowThreads(__tstate);
18941 if (PyErr_Occurred()) SWIG_fail;
18942 }
18943 {
18944 #if wxUSE_UNICODE
18945 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18946 #else
18947 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18948 #endif
18949 }
18950 {
18951 if (temp1)
18952 delete arg1;
18953 }
18954 return resultobj;
18955 fail:
18956 {
18957 if (temp1)
18958 delete arg1;
18959 }
18960 return NULL;
18961 }
18962
18963
18964 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18965 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18966 return 1;
18967 }
18968
18969
18970 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18971 PyObject *pyobj;
18972
18973 {
18974 #if wxUSE_UNICODE
18975 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18976 #else
18977 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18978 #endif
18979 }
18980 return pyobj;
18981 }
18982
18983
18984 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18985 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18986 return 1;
18987 }
18988
18989
18990 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18991 PyObject *pyobj;
18992
18993 {
18994 #if wxUSE_UNICODE
18995 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18996 #else
18997 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18998 #endif
18999 }
19000 return pyobj;
19001 }
19002
19003
19004 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19005 PyObject *resultobj;
19006 wxDateTime::Country arg1 ;
19007 PyObject * obj0 = 0 ;
19008 char *kwnames[] = {
19009 (char *) "country", NULL
19010 };
19011
19012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
19013 {
19014 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19015 if (SWIG_arg_fail(1)) SWIG_fail;
19016 }
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 wxDateTime::SetCountry((wxDateTime::Country )arg1);
19020
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 Py_INCREF(Py_None); resultobj = Py_None;
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxDateTime::Country result;
19034 char *kwnames[] = {
19035 NULL
19036 };
19037
19038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
19039 {
19040 PyThreadState* __tstate = wxPyBeginAllowThreads();
19041 result = (wxDateTime::Country)wxDateTime::GetCountry();
19042
19043 wxPyEndAllowThreads(__tstate);
19044 if (PyErr_Occurred()) SWIG_fail;
19045 }
19046 resultobj = SWIG_From_int((result));
19047 return resultobj;
19048 fail:
19049 return NULL;
19050 }
19051
19052
19053 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
19054 PyObject *resultobj;
19055 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19056 bool result;
19057 PyObject * obj0 = 0 ;
19058 char *kwnames[] = {
19059 (char *) "country", NULL
19060 };
19061
19062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19063 if (obj0) {
19064 {
19065 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19066 if (SWIG_arg_fail(1)) SWIG_fail;
19067 }
19068 }
19069 {
19070 PyThreadState* __tstate = wxPyBeginAllowThreads();
19071 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19072
19073 wxPyEndAllowThreads(__tstate);
19074 if (PyErr_Occurred()) SWIG_fail;
19075 }
19076 {
19077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19078 }
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19088 int result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "cal", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19095 if (obj0) {
19096 {
19097 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19098 if (SWIG_arg_fail(1)) SWIG_fail;
19099 }
19100 }
19101 {
19102 PyThreadState* __tstate = wxPyBeginAllowThreads();
19103 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19104
19105 wxPyEndAllowThreads(__tstate);
19106 if (PyErr_Occurred()) SWIG_fail;
19107 }
19108 {
19109 resultobj = SWIG_From_int((int)(result));
19110 }
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19118 PyObject *resultobj;
19119 int arg1 ;
19120 int result;
19121 PyObject * obj0 = 0 ;
19122 char *kwnames[] = {
19123 (char *) "year", NULL
19124 };
19125
19126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19127 {
19128 arg1 = (int)(SWIG_As_int(obj0));
19129 if (SWIG_arg_fail(1)) SWIG_fail;
19130 }
19131 {
19132 PyThreadState* __tstate = wxPyBeginAllowThreads();
19133 result = (int)wxDateTime::ConvertYearToBC(arg1);
19134
19135 wxPyEndAllowThreads(__tstate);
19136 if (PyErr_Occurred()) SWIG_fail;
19137 }
19138 {
19139 resultobj = SWIG_From_int((int)(result));
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19148 PyObject *resultobj;
19149 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19150 wxDateTime::Month result;
19151 PyObject * obj0 = 0 ;
19152 char *kwnames[] = {
19153 (char *) "cal", NULL
19154 };
19155
19156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19157 if (obj0) {
19158 {
19159 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19160 if (SWIG_arg_fail(1)) SWIG_fail;
19161 }
19162 }
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19166
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_From_int((result));
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19178 PyObject *resultobj;
19179 int arg1 = (int) wxDateTime::Inv_Year ;
19180 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19181 bool result;
19182 PyObject * obj0 = 0 ;
19183 PyObject * obj1 = 0 ;
19184 char *kwnames[] = {
19185 (char *) "year",(char *) "cal", NULL
19186 };
19187
19188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19189 if (obj0) {
19190 {
19191 arg1 = (int)(SWIG_As_int(obj0));
19192 if (SWIG_arg_fail(1)) SWIG_fail;
19193 }
19194 }
19195 if (obj1) {
19196 {
19197 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19198 if (SWIG_arg_fail(2)) SWIG_fail;
19199 }
19200 }
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19204
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 {
19209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19210 }
19211 return resultobj;
19212 fail:
19213 return NULL;
19214 }
19215
19216
19217 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 int arg1 = (int) wxDateTime::Inv_Year ;
19220 int result;
19221 PyObject * obj0 = 0 ;
19222 char *kwnames[] = {
19223 (char *) "year", NULL
19224 };
19225
19226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19227 if (obj0) {
19228 {
19229 arg1 = (int)(SWIG_As_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 }
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (int)wxDateTime::GetCentury(arg1);
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = SWIG_From_int((int)(result));
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj;
19251 int arg1 ;
19252 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19253 int result;
19254 PyObject * obj0 = 0 ;
19255 PyObject * obj1 = 0 ;
19256 char *kwnames[] = {
19257 (char *) "year",(char *) "cal", NULL
19258 };
19259
19260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19261 {
19262 arg1 = (int)(SWIG_As_int(obj0));
19263 if (SWIG_arg_fail(1)) SWIG_fail;
19264 }
19265 if (obj1) {
19266 {
19267 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19268 if (SWIG_arg_fail(2)) SWIG_fail;
19269 }
19270 }
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19274
19275 wxPyEndAllowThreads(__tstate);
19276 if (PyErr_Occurred()) SWIG_fail;
19277 }
19278 {
19279 resultobj = SWIG_From_int((int)(result));
19280 }
19281 return resultobj;
19282 fail:
19283 return NULL;
19284 }
19285
19286
19287 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19288 PyObject *resultobj;
19289 wxDateTime::Month arg1 ;
19290 int arg2 = (int) wxDateTime::Inv_Year ;
19291 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19292 int result;
19293 PyObject * obj0 = 0 ;
19294 PyObject * obj1 = 0 ;
19295 PyObject * obj2 = 0 ;
19296 char *kwnames[] = {
19297 (char *) "month",(char *) "year",(char *) "cal", NULL
19298 };
19299
19300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19301 {
19302 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19303 if (SWIG_arg_fail(1)) SWIG_fail;
19304 }
19305 if (obj1) {
19306 {
19307 arg2 = (int)(SWIG_As_int(obj1));
19308 if (SWIG_arg_fail(2)) SWIG_fail;
19309 }
19310 }
19311 if (obj2) {
19312 {
19313 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19314 if (SWIG_arg_fail(3)) SWIG_fail;
19315 }
19316 }
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19320
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 {
19325 resultobj = SWIG_From_int((int)(result));
19326 }
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj;
19335 wxDateTime::Month arg1 ;
19336 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19337 wxString result;
19338 PyObject * obj0 = 0 ;
19339 PyObject * obj1 = 0 ;
19340 char *kwnames[] = {
19341 (char *) "month",(char *) "flags", NULL
19342 };
19343
19344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19345 {
19346 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19347 if (SWIG_arg_fail(1)) SWIG_fail;
19348 }
19349 if (obj1) {
19350 {
19351 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19352 if (SWIG_arg_fail(2)) SWIG_fail;
19353 }
19354 }
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19358
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 {
19363 #if wxUSE_UNICODE
19364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19365 #else
19366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19367 #endif
19368 }
19369 return resultobj;
19370 fail:
19371 return NULL;
19372 }
19373
19374
19375 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19376 PyObject *resultobj;
19377 wxDateTime::WeekDay arg1 ;
19378 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19379 wxString result;
19380 PyObject * obj0 = 0 ;
19381 PyObject * obj1 = 0 ;
19382 char *kwnames[] = {
19383 (char *) "weekday",(char *) "flags", NULL
19384 };
19385
19386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19387 {
19388 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 }
19391 if (obj1) {
19392 {
19393 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19394 if (SWIG_arg_fail(2)) SWIG_fail;
19395 }
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19400
19401 wxPyEndAllowThreads(__tstate);
19402 if (PyErr_Occurred()) SWIG_fail;
19403 }
19404 {
19405 #if wxUSE_UNICODE
19406 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19407 #else
19408 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19409 #endif
19410 }
19411 return resultobj;
19412 fail:
19413 return NULL;
19414 }
19415
19416
19417 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19418 PyObject *resultobj;
19419 PyObject *result;
19420 char *kwnames[] = {
19421 NULL
19422 };
19423
19424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (PyObject *)DateTime_GetAmPmStrings();
19428
19429 wxPyEndAllowThreads(__tstate);
19430 if (PyErr_Occurred()) SWIG_fail;
19431 }
19432 resultobj = result;
19433 return resultobj;
19434 fail:
19435 return NULL;
19436 }
19437
19438
19439 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19440 PyObject *resultobj;
19441 int arg1 = (int) wxDateTime::Inv_Year ;
19442 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19443 bool result;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char *kwnames[] = {
19447 (char *) "year",(char *) "country", NULL
19448 };
19449
19450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19451 if (obj0) {
19452 {
19453 arg1 = (int)(SWIG_As_int(obj0));
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 }
19456 }
19457 if (obj1) {
19458 {
19459 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19460 if (SWIG_arg_fail(2)) SWIG_fail;
19461 }
19462 }
19463 {
19464 PyThreadState* __tstate = wxPyBeginAllowThreads();
19465 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19466
19467 wxPyEndAllowThreads(__tstate);
19468 if (PyErr_Occurred()) SWIG_fail;
19469 }
19470 {
19471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19472 }
19473 return resultobj;
19474 fail:
19475 return NULL;
19476 }
19477
19478
19479 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19480 PyObject *resultobj;
19481 int arg1 = (int) wxDateTime::Inv_Year ;
19482 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19483 wxDateTime result;
19484 PyObject * obj0 = 0 ;
19485 PyObject * obj1 = 0 ;
19486 char *kwnames[] = {
19487 (char *) "year",(char *) "country", NULL
19488 };
19489
19490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19491 if (obj0) {
19492 {
19493 arg1 = (int)(SWIG_As_int(obj0));
19494 if (SWIG_arg_fail(1)) SWIG_fail;
19495 }
19496 }
19497 if (obj1) {
19498 {
19499 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19500 if (SWIG_arg_fail(2)) SWIG_fail;
19501 }
19502 }
19503 {
19504 PyThreadState* __tstate = wxPyBeginAllowThreads();
19505 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19506
19507 wxPyEndAllowThreads(__tstate);
19508 if (PyErr_Occurred()) SWIG_fail;
19509 }
19510 {
19511 wxDateTime * resultptr;
19512 resultptr = new wxDateTime((wxDateTime &)(result));
19513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19514 }
19515 return resultobj;
19516 fail:
19517 return NULL;
19518 }
19519
19520
19521 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19522 PyObject *resultobj;
19523 int arg1 = (int) wxDateTime::Inv_Year ;
19524 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19525 wxDateTime result;
19526 PyObject * obj0 = 0 ;
19527 PyObject * obj1 = 0 ;
19528 char *kwnames[] = {
19529 (char *) "year",(char *) "country", NULL
19530 };
19531
19532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19533 if (obj0) {
19534 {
19535 arg1 = (int)(SWIG_As_int(obj0));
19536 if (SWIG_arg_fail(1)) SWIG_fail;
19537 }
19538 }
19539 if (obj1) {
19540 {
19541 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19542 if (SWIG_arg_fail(2)) SWIG_fail;
19543 }
19544 }
19545 {
19546 PyThreadState* __tstate = wxPyBeginAllowThreads();
19547 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19548
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 {
19553 wxDateTime * resultptr;
19554 resultptr = new wxDateTime((wxDateTime &)(result));
19555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19556 }
19557 return resultobj;
19558 fail:
19559 return NULL;
19560 }
19561
19562
19563 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19564 PyObject *resultobj;
19565 wxDateTime result;
19566 char *kwnames[] = {
19567 NULL
19568 };
19569
19570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19571 {
19572 PyThreadState* __tstate = wxPyBeginAllowThreads();
19573 result = wxDateTime::Now();
19574
19575 wxPyEndAllowThreads(__tstate);
19576 if (PyErr_Occurred()) SWIG_fail;
19577 }
19578 {
19579 wxDateTime * resultptr;
19580 resultptr = new wxDateTime((wxDateTime &)(result));
19581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19582 }
19583 return resultobj;
19584 fail:
19585 return NULL;
19586 }
19587
19588
19589 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19590 PyObject *resultobj;
19591 wxDateTime result;
19592 char *kwnames[] = {
19593 NULL
19594 };
19595
19596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = wxDateTime::UNow();
19600
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 {
19605 wxDateTime * resultptr;
19606 resultptr = new wxDateTime((wxDateTime &)(result));
19607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19608 }
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19616 PyObject *resultobj;
19617 wxDateTime result;
19618 char *kwnames[] = {
19619 NULL
19620 };
19621
19622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19623 {
19624 PyThreadState* __tstate = wxPyBeginAllowThreads();
19625 result = wxDateTime::Today();
19626
19627 wxPyEndAllowThreads(__tstate);
19628 if (PyErr_Occurred()) SWIG_fail;
19629 }
19630 {
19631 wxDateTime * resultptr;
19632 resultptr = new wxDateTime((wxDateTime &)(result));
19633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19634 }
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj;
19643 wxDateTime *result;
19644 char *kwnames[] = {
19645 NULL
19646 };
19647
19648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 result = (wxDateTime *)new wxDateTime();
19652
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 time_t arg1 ;
19666 wxDateTime *result;
19667 PyObject * obj0 = 0 ;
19668 char *kwnames[] = {
19669 (char *) "timet", NULL
19670 };
19671
19672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19673 {
19674 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 }
19677 {
19678 PyThreadState* __tstate = wxPyBeginAllowThreads();
19679 result = (wxDateTime *)new wxDateTime(arg1);
19680
19681 wxPyEndAllowThreads(__tstate);
19682 if (PyErr_Occurred()) SWIG_fail;
19683 }
19684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19685 return resultobj;
19686 fail:
19687 return NULL;
19688 }
19689
19690
19691 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19692 PyObject *resultobj;
19693 double arg1 ;
19694 wxDateTime *result;
19695 PyObject * obj0 = 0 ;
19696 char *kwnames[] = {
19697 (char *) "jdn", NULL
19698 };
19699
19700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19701 {
19702 arg1 = (double)(SWIG_As_double(obj0));
19703 if (SWIG_arg_fail(1)) SWIG_fail;
19704 }
19705 {
19706 PyThreadState* __tstate = wxPyBeginAllowThreads();
19707 result = (wxDateTime *)new wxDateTime(arg1);
19708
19709 wxPyEndAllowThreads(__tstate);
19710 if (PyErr_Occurred()) SWIG_fail;
19711 }
19712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19713 return resultobj;
19714 fail:
19715 return NULL;
19716 }
19717
19718
19719 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19720 PyObject *resultobj;
19721 int arg1 ;
19722 int arg2 = (int) 0 ;
19723 int arg3 = (int) 0 ;
19724 int arg4 = (int) 0 ;
19725 wxDateTime *result;
19726 PyObject * obj0 = 0 ;
19727 PyObject * obj1 = 0 ;
19728 PyObject * obj2 = 0 ;
19729 PyObject * obj3 = 0 ;
19730 char *kwnames[] = {
19731 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19732 };
19733
19734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19735 {
19736 arg1 = (int)(SWIG_As_int(obj0));
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 }
19739 if (obj1) {
19740 {
19741 arg2 = (int)(SWIG_As_int(obj1));
19742 if (SWIG_arg_fail(2)) SWIG_fail;
19743 }
19744 }
19745 if (obj2) {
19746 {
19747 arg3 = (int)(SWIG_As_int(obj2));
19748 if (SWIG_arg_fail(3)) SWIG_fail;
19749 }
19750 }
19751 if (obj3) {
19752 {
19753 arg4 = (int)(SWIG_As_int(obj3));
19754 if (SWIG_arg_fail(4)) SWIG_fail;
19755 }
19756 }
19757 {
19758 PyThreadState* __tstate = wxPyBeginAllowThreads();
19759 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19760
19761 wxPyEndAllowThreads(__tstate);
19762 if (PyErr_Occurred()) SWIG_fail;
19763 }
19764 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19765 return resultobj;
19766 fail:
19767 return NULL;
19768 }
19769
19770
19771 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19772 PyObject *resultobj;
19773 int arg1 ;
19774 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19775 int arg3 = (int) wxDateTime::Inv_Year ;
19776 int arg4 = (int) 0 ;
19777 int arg5 = (int) 0 ;
19778 int arg6 = (int) 0 ;
19779 int arg7 = (int) 0 ;
19780 wxDateTime *result;
19781 PyObject * obj0 = 0 ;
19782 PyObject * obj1 = 0 ;
19783 PyObject * obj2 = 0 ;
19784 PyObject * obj3 = 0 ;
19785 PyObject * obj4 = 0 ;
19786 PyObject * obj5 = 0 ;
19787 PyObject * obj6 = 0 ;
19788 char *kwnames[] = {
19789 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19790 };
19791
19792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19793 {
19794 arg1 = (int)(SWIG_As_int(obj0));
19795 if (SWIG_arg_fail(1)) SWIG_fail;
19796 }
19797 if (obj1) {
19798 {
19799 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19800 if (SWIG_arg_fail(2)) SWIG_fail;
19801 }
19802 }
19803 if (obj2) {
19804 {
19805 arg3 = (int)(SWIG_As_int(obj2));
19806 if (SWIG_arg_fail(3)) SWIG_fail;
19807 }
19808 }
19809 if (obj3) {
19810 {
19811 arg4 = (int)(SWIG_As_int(obj3));
19812 if (SWIG_arg_fail(4)) SWIG_fail;
19813 }
19814 }
19815 if (obj4) {
19816 {
19817 arg5 = (int)(SWIG_As_int(obj4));
19818 if (SWIG_arg_fail(5)) SWIG_fail;
19819 }
19820 }
19821 if (obj5) {
19822 {
19823 arg6 = (int)(SWIG_As_int(obj5));
19824 if (SWIG_arg_fail(6)) SWIG_fail;
19825 }
19826 }
19827 if (obj6) {
19828 {
19829 arg7 = (int)(SWIG_As_int(obj6));
19830 if (SWIG_arg_fail(7)) SWIG_fail;
19831 }
19832 }
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19836
19837 wxPyEndAllowThreads(__tstate);
19838 if (PyErr_Occurred()) SWIG_fail;
19839 }
19840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19841 return resultobj;
19842 fail:
19843 return NULL;
19844 }
19845
19846
19847 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19848 PyObject *resultobj;
19849 wxDateTime *arg1 = (wxDateTime *) 0 ;
19850 PyObject * obj0 = 0 ;
19851 char *kwnames[] = {
19852 (char *) "self", NULL
19853 };
19854
19855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19857 if (SWIG_arg_fail(1)) SWIG_fail;
19858 {
19859 PyThreadState* __tstate = wxPyBeginAllowThreads();
19860 delete arg1;
19861
19862 wxPyEndAllowThreads(__tstate);
19863 if (PyErr_Occurred()) SWIG_fail;
19864 }
19865 Py_INCREF(Py_None); resultobj = Py_None;
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj;
19874 wxDateTime *arg1 = (wxDateTime *) 0 ;
19875 wxDateTime *result;
19876 PyObject * obj0 = 0 ;
19877 char *kwnames[] = {
19878 (char *) "self", NULL
19879 };
19880
19881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19883 if (SWIG_arg_fail(1)) SWIG_fail;
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 {
19887 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19888 result = (wxDateTime *) &_result_ref;
19889 }
19890
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19895 return resultobj;
19896 fail:
19897 return NULL;
19898 }
19899
19900
19901 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19902 PyObject *resultobj;
19903 wxDateTime *arg1 = (wxDateTime *) 0 ;
19904 time_t arg2 ;
19905 wxDateTime *result;
19906 PyObject * obj0 = 0 ;
19907 PyObject * obj1 = 0 ;
19908 char *kwnames[] = {
19909 (char *) "self",(char *) "timet", NULL
19910 };
19911
19912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19914 if (SWIG_arg_fail(1)) SWIG_fail;
19915 {
19916 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19917 if (SWIG_arg_fail(2)) SWIG_fail;
19918 }
19919 {
19920 PyThreadState* __tstate = wxPyBeginAllowThreads();
19921 {
19922 wxDateTime &_result_ref = (arg1)->Set(arg2);
19923 result = (wxDateTime *) &_result_ref;
19924 }
19925
19926 wxPyEndAllowThreads(__tstate);
19927 if (PyErr_Occurred()) SWIG_fail;
19928 }
19929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19930 return resultobj;
19931 fail:
19932 return NULL;
19933 }
19934
19935
19936 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19937 PyObject *resultobj;
19938 wxDateTime *arg1 = (wxDateTime *) 0 ;
19939 double arg2 ;
19940 wxDateTime *result;
19941 PyObject * obj0 = 0 ;
19942 PyObject * obj1 = 0 ;
19943 char *kwnames[] = {
19944 (char *) "self",(char *) "jdn", NULL
19945 };
19946
19947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(1)) SWIG_fail;
19950 {
19951 arg2 = (double)(SWIG_As_double(obj1));
19952 if (SWIG_arg_fail(2)) SWIG_fail;
19953 }
19954 {
19955 PyThreadState* __tstate = wxPyBeginAllowThreads();
19956 {
19957 wxDateTime &_result_ref = (arg1)->Set(arg2);
19958 result = (wxDateTime *) &_result_ref;
19959 }
19960
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19965 return resultobj;
19966 fail:
19967 return NULL;
19968 }
19969
19970
19971 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19972 PyObject *resultobj;
19973 wxDateTime *arg1 = (wxDateTime *) 0 ;
19974 int arg2 ;
19975 int arg3 = (int) 0 ;
19976 int arg4 = (int) 0 ;
19977 int arg5 = (int) 0 ;
19978 wxDateTime *result;
19979 PyObject * obj0 = 0 ;
19980 PyObject * obj1 = 0 ;
19981 PyObject * obj2 = 0 ;
19982 PyObject * obj3 = 0 ;
19983 PyObject * obj4 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19990 if (SWIG_arg_fail(1)) SWIG_fail;
19991 {
19992 arg2 = (int)(SWIG_As_int(obj1));
19993 if (SWIG_arg_fail(2)) SWIG_fail;
19994 }
19995 if (obj2) {
19996 {
19997 arg3 = (int)(SWIG_As_int(obj2));
19998 if (SWIG_arg_fail(3)) SWIG_fail;
19999 }
20000 }
20001 if (obj3) {
20002 {
20003 arg4 = (int)(SWIG_As_int(obj3));
20004 if (SWIG_arg_fail(4)) SWIG_fail;
20005 }
20006 }
20007 if (obj4) {
20008 {
20009 arg5 = (int)(SWIG_As_int(obj4));
20010 if (SWIG_arg_fail(5)) SWIG_fail;
20011 }
20012 }
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 {
20016 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
20017 result = (wxDateTime *) &_result_ref;
20018 }
20019
20020 wxPyEndAllowThreads(__tstate);
20021 if (PyErr_Occurred()) SWIG_fail;
20022 }
20023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20024 return resultobj;
20025 fail:
20026 return NULL;
20027 }
20028
20029
20030 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
20031 PyObject *resultobj;
20032 wxDateTime *arg1 = (wxDateTime *) 0 ;
20033 int arg2 ;
20034 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20035 int arg4 = (int) wxDateTime::Inv_Year ;
20036 int arg5 = (int) 0 ;
20037 int arg6 = (int) 0 ;
20038 int arg7 = (int) 0 ;
20039 int arg8 = (int) 0 ;
20040 wxDateTime *result;
20041 PyObject * obj0 = 0 ;
20042 PyObject * obj1 = 0 ;
20043 PyObject * obj2 = 0 ;
20044 PyObject * obj3 = 0 ;
20045 PyObject * obj4 = 0 ;
20046 PyObject * obj5 = 0 ;
20047 PyObject * obj6 = 0 ;
20048 PyObject * obj7 = 0 ;
20049 char *kwnames[] = {
20050 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
20051 };
20052
20053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
20054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20055 if (SWIG_arg_fail(1)) SWIG_fail;
20056 {
20057 arg2 = (int)(SWIG_As_int(obj1));
20058 if (SWIG_arg_fail(2)) SWIG_fail;
20059 }
20060 if (obj2) {
20061 {
20062 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20063 if (SWIG_arg_fail(3)) SWIG_fail;
20064 }
20065 }
20066 if (obj3) {
20067 {
20068 arg4 = (int)(SWIG_As_int(obj3));
20069 if (SWIG_arg_fail(4)) SWIG_fail;
20070 }
20071 }
20072 if (obj4) {
20073 {
20074 arg5 = (int)(SWIG_As_int(obj4));
20075 if (SWIG_arg_fail(5)) SWIG_fail;
20076 }
20077 }
20078 if (obj5) {
20079 {
20080 arg6 = (int)(SWIG_As_int(obj5));
20081 if (SWIG_arg_fail(6)) SWIG_fail;
20082 }
20083 }
20084 if (obj6) {
20085 {
20086 arg7 = (int)(SWIG_As_int(obj6));
20087 if (SWIG_arg_fail(7)) SWIG_fail;
20088 }
20089 }
20090 if (obj7) {
20091 {
20092 arg8 = (int)(SWIG_As_int(obj7));
20093 if (SWIG_arg_fail(8)) SWIG_fail;
20094 }
20095 }
20096 {
20097 PyThreadState* __tstate = wxPyBeginAllowThreads();
20098 {
20099 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20100 result = (wxDateTime *) &_result_ref;
20101 }
20102
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj;
20115 wxDateTime *arg1 = (wxDateTime *) 0 ;
20116 wxDateTime *result;
20117 PyObject * obj0 = 0 ;
20118 char *kwnames[] = {
20119 (char *) "self", NULL
20120 };
20121
20122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20124 if (SWIG_arg_fail(1)) SWIG_fail;
20125 {
20126 PyThreadState* __tstate = wxPyBeginAllowThreads();
20127 {
20128 wxDateTime &_result_ref = (arg1)->ResetTime();
20129 result = (wxDateTime *) &_result_ref;
20130 }
20131
20132 wxPyEndAllowThreads(__tstate);
20133 if (PyErr_Occurred()) SWIG_fail;
20134 }
20135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20136 return resultobj;
20137 fail:
20138 return NULL;
20139 }
20140
20141
20142 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20143 PyObject *resultobj;
20144 wxDateTime *arg1 = (wxDateTime *) 0 ;
20145 int arg2 ;
20146 wxDateTime *result;
20147 PyObject * obj0 = 0 ;
20148 PyObject * obj1 = 0 ;
20149 char *kwnames[] = {
20150 (char *) "self",(char *) "year", NULL
20151 };
20152
20153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20155 if (SWIG_arg_fail(1)) SWIG_fail;
20156 {
20157 arg2 = (int)(SWIG_As_int(obj1));
20158 if (SWIG_arg_fail(2)) SWIG_fail;
20159 }
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 {
20163 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20164 result = (wxDateTime *) &_result_ref;
20165 }
20166
20167 wxPyEndAllowThreads(__tstate);
20168 if (PyErr_Occurred()) SWIG_fail;
20169 }
20170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20171 return resultobj;
20172 fail:
20173 return NULL;
20174 }
20175
20176
20177 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20178 PyObject *resultobj;
20179 wxDateTime *arg1 = (wxDateTime *) 0 ;
20180 wxDateTime::Month arg2 ;
20181 wxDateTime *result;
20182 PyObject * obj0 = 0 ;
20183 PyObject * obj1 = 0 ;
20184 char *kwnames[] = {
20185 (char *) "self",(char *) "month", NULL
20186 };
20187
20188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20190 if (SWIG_arg_fail(1)) SWIG_fail;
20191 {
20192 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20193 if (SWIG_arg_fail(2)) SWIG_fail;
20194 }
20195 {
20196 PyThreadState* __tstate = wxPyBeginAllowThreads();
20197 {
20198 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20199 result = (wxDateTime *) &_result_ref;
20200 }
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20213 PyObject *resultobj;
20214 wxDateTime *arg1 = (wxDateTime *) 0 ;
20215 int arg2 ;
20216 wxDateTime *result;
20217 PyObject * obj0 = 0 ;
20218 PyObject * obj1 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self",(char *) "day", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 arg2 = (int)(SWIG_As_int(obj1));
20228 if (SWIG_arg_fail(2)) SWIG_fail;
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 {
20233 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20234 result = (wxDateTime *) &_result_ref;
20235 }
20236
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20248 PyObject *resultobj;
20249 wxDateTime *arg1 = (wxDateTime *) 0 ;
20250 int arg2 ;
20251 wxDateTime *result;
20252 PyObject * obj0 = 0 ;
20253 PyObject * obj1 = 0 ;
20254 char *kwnames[] = {
20255 (char *) "self",(char *) "hour", NULL
20256 };
20257
20258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20260 if (SWIG_arg_fail(1)) SWIG_fail;
20261 {
20262 arg2 = (int)(SWIG_As_int(obj1));
20263 if (SWIG_arg_fail(2)) SWIG_fail;
20264 }
20265 {
20266 PyThreadState* __tstate = wxPyBeginAllowThreads();
20267 {
20268 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20269 result = (wxDateTime *) &_result_ref;
20270 }
20271
20272 wxPyEndAllowThreads(__tstate);
20273 if (PyErr_Occurred()) SWIG_fail;
20274 }
20275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20283 PyObject *resultobj;
20284 wxDateTime *arg1 = (wxDateTime *) 0 ;
20285 int arg2 ;
20286 wxDateTime *result;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 char *kwnames[] = {
20290 (char *) "self",(char *) "minute", NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20295 if (SWIG_arg_fail(1)) SWIG_fail;
20296 {
20297 arg2 = (int)(SWIG_As_int(obj1));
20298 if (SWIG_arg_fail(2)) SWIG_fail;
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 {
20303 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20304 result = (wxDateTime *) &_result_ref;
20305 }
20306
20307 wxPyEndAllowThreads(__tstate);
20308 if (PyErr_Occurred()) SWIG_fail;
20309 }
20310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20311 return resultobj;
20312 fail:
20313 return NULL;
20314 }
20315
20316
20317 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20318 PyObject *resultobj;
20319 wxDateTime *arg1 = (wxDateTime *) 0 ;
20320 int arg2 ;
20321 wxDateTime *result;
20322 PyObject * obj0 = 0 ;
20323 PyObject * obj1 = 0 ;
20324 char *kwnames[] = {
20325 (char *) "self",(char *) "second", NULL
20326 };
20327
20328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20330 if (SWIG_arg_fail(1)) SWIG_fail;
20331 {
20332 arg2 = (int)(SWIG_As_int(obj1));
20333 if (SWIG_arg_fail(2)) SWIG_fail;
20334 }
20335 {
20336 PyThreadState* __tstate = wxPyBeginAllowThreads();
20337 {
20338 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20339 result = (wxDateTime *) &_result_ref;
20340 }
20341
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20346 return resultobj;
20347 fail:
20348 return NULL;
20349 }
20350
20351
20352 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20353 PyObject *resultobj;
20354 wxDateTime *arg1 = (wxDateTime *) 0 ;
20355 int arg2 ;
20356 wxDateTime *result;
20357 PyObject * obj0 = 0 ;
20358 PyObject * obj1 = 0 ;
20359 char *kwnames[] = {
20360 (char *) "self",(char *) "millisecond", NULL
20361 };
20362
20363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20365 if (SWIG_arg_fail(1)) SWIG_fail;
20366 {
20367 arg2 = (int)(SWIG_As_int(obj1));
20368 if (SWIG_arg_fail(2)) SWIG_fail;
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 {
20373 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20374 result = (wxDateTime *) &_result_ref;
20375 }
20376
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20381 return resultobj;
20382 fail:
20383 return NULL;
20384 }
20385
20386
20387 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20388 PyObject *resultobj;
20389 wxDateTime *arg1 = (wxDateTime *) 0 ;
20390 wxDateTime::WeekDay arg2 ;
20391 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20392 wxDateTime *result;
20393 PyObject * obj0 = 0 ;
20394 PyObject * obj1 = 0 ;
20395 PyObject * obj2 = 0 ;
20396 char *kwnames[] = {
20397 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20398 };
20399
20400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20402 if (SWIG_arg_fail(1)) SWIG_fail;
20403 {
20404 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20405 if (SWIG_arg_fail(2)) SWIG_fail;
20406 }
20407 if (obj2) {
20408 {
20409 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20410 if (SWIG_arg_fail(3)) SWIG_fail;
20411 }
20412 }
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 {
20416 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20417 result = (wxDateTime *) &_result_ref;
20418 }
20419
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20424 return resultobj;
20425 fail:
20426 return NULL;
20427 }
20428
20429
20430 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20431 PyObject *resultobj;
20432 wxDateTime *arg1 = (wxDateTime *) 0 ;
20433 wxDateTime::WeekDay arg2 ;
20434 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20435 wxDateTime result;
20436 PyObject * obj0 = 0 ;
20437 PyObject * obj1 = 0 ;
20438 PyObject * obj2 = 0 ;
20439 char *kwnames[] = {
20440 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20441 };
20442
20443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20445 if (SWIG_arg_fail(1)) SWIG_fail;
20446 {
20447 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20448 if (SWIG_arg_fail(2)) SWIG_fail;
20449 }
20450 if (obj2) {
20451 {
20452 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20453 if (SWIG_arg_fail(3)) SWIG_fail;
20454 }
20455 }
20456 {
20457 PyThreadState* __tstate = wxPyBeginAllowThreads();
20458 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20459
20460 wxPyEndAllowThreads(__tstate);
20461 if (PyErr_Occurred()) SWIG_fail;
20462 }
20463 {
20464 wxDateTime * resultptr;
20465 resultptr = new wxDateTime((wxDateTime &)(result));
20466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20467 }
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj;
20476 wxDateTime *arg1 = (wxDateTime *) 0 ;
20477 wxDateTime::WeekDay arg2 ;
20478 wxDateTime *result;
20479 PyObject * obj0 = 0 ;
20480 PyObject * obj1 = 0 ;
20481 char *kwnames[] = {
20482 (char *) "self",(char *) "weekday", NULL
20483 };
20484
20485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20487 if (SWIG_arg_fail(1)) SWIG_fail;
20488 {
20489 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20490 if (SWIG_arg_fail(2)) SWIG_fail;
20491 }
20492 {
20493 PyThreadState* __tstate = wxPyBeginAllowThreads();
20494 {
20495 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20496 result = (wxDateTime *) &_result_ref;
20497 }
20498
20499 wxPyEndAllowThreads(__tstate);
20500 if (PyErr_Occurred()) SWIG_fail;
20501 }
20502 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20503 return resultobj;
20504 fail:
20505 return NULL;
20506 }
20507
20508
20509 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20510 PyObject *resultobj;
20511 wxDateTime *arg1 = (wxDateTime *) 0 ;
20512 wxDateTime::WeekDay arg2 ;
20513 wxDateTime result;
20514 PyObject * obj0 = 0 ;
20515 PyObject * obj1 = 0 ;
20516 char *kwnames[] = {
20517 (char *) "self",(char *) "weekday", NULL
20518 };
20519
20520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20522 if (SWIG_arg_fail(1)) SWIG_fail;
20523 {
20524 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20525 if (SWIG_arg_fail(2)) SWIG_fail;
20526 }
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20530
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 wxDateTime * resultptr;
20536 resultptr = new wxDateTime((wxDateTime &)(result));
20537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20538 }
20539 return resultobj;
20540 fail:
20541 return NULL;
20542 }
20543
20544
20545 static PyObject *_wrap_DateTime_SetToPrevWeekDay(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_SetToPrevWeekDay",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 {
20566 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20567 result = (wxDateTime *) &_result_ref;
20568 }
20569
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20574 return resultobj;
20575 fail:
20576 return NULL;
20577 }
20578
20579
20580 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20581 PyObject *resultobj;
20582 wxDateTime *arg1 = (wxDateTime *) 0 ;
20583 wxDateTime::WeekDay arg2 ;
20584 wxDateTime result;
20585 PyObject * obj0 = 0 ;
20586 PyObject * obj1 = 0 ;
20587 char *kwnames[] = {
20588 (char *) "self",(char *) "weekday", NULL
20589 };
20590
20591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20593 if (SWIG_arg_fail(1)) SWIG_fail;
20594 {
20595 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20596 if (SWIG_arg_fail(2)) SWIG_fail;
20597 }
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20601
20602 wxPyEndAllowThreads(__tstate);
20603 if (PyErr_Occurred()) SWIG_fail;
20604 }
20605 {
20606 wxDateTime * resultptr;
20607 resultptr = new wxDateTime((wxDateTime &)(result));
20608 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20609 }
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20617 PyObject *resultobj;
20618 wxDateTime *arg1 = (wxDateTime *) 0 ;
20619 wxDateTime::WeekDay arg2 ;
20620 int arg3 = (int) 1 ;
20621 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20622 int arg5 = (int) wxDateTime::Inv_Year ;
20623 bool result;
20624 PyObject * obj0 = 0 ;
20625 PyObject * obj1 = 0 ;
20626 PyObject * obj2 = 0 ;
20627 PyObject * obj3 = 0 ;
20628 PyObject * obj4 = 0 ;
20629 char *kwnames[] = {
20630 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20631 };
20632
20633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20635 if (SWIG_arg_fail(1)) SWIG_fail;
20636 {
20637 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20638 if (SWIG_arg_fail(2)) SWIG_fail;
20639 }
20640 if (obj2) {
20641 {
20642 arg3 = (int)(SWIG_As_int(obj2));
20643 if (SWIG_arg_fail(3)) SWIG_fail;
20644 }
20645 }
20646 if (obj3) {
20647 {
20648 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20649 if (SWIG_arg_fail(4)) SWIG_fail;
20650 }
20651 }
20652 if (obj4) {
20653 {
20654 arg5 = (int)(SWIG_As_int(obj4));
20655 if (SWIG_arg_fail(5)) SWIG_fail;
20656 }
20657 }
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20661
20662 wxPyEndAllowThreads(__tstate);
20663 if (PyErr_Occurred()) SWIG_fail;
20664 }
20665 {
20666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20667 }
20668 return resultobj;
20669 fail:
20670 return NULL;
20671 }
20672
20673
20674 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20675 PyObject *resultobj;
20676 wxDateTime *arg1 = (wxDateTime *) 0 ;
20677 wxDateTime::WeekDay arg2 ;
20678 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20679 int arg4 = (int) wxDateTime::Inv_Year ;
20680 bool result;
20681 PyObject * obj0 = 0 ;
20682 PyObject * obj1 = 0 ;
20683 PyObject * obj2 = 0 ;
20684 PyObject * obj3 = 0 ;
20685 char *kwnames[] = {
20686 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20687 };
20688
20689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20691 if (SWIG_arg_fail(1)) SWIG_fail;
20692 {
20693 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20694 if (SWIG_arg_fail(2)) SWIG_fail;
20695 }
20696 if (obj2) {
20697 {
20698 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20699 if (SWIG_arg_fail(3)) SWIG_fail;
20700 }
20701 }
20702 if (obj3) {
20703 {
20704 arg4 = (int)(SWIG_As_int(obj3));
20705 if (SWIG_arg_fail(4)) SWIG_fail;
20706 }
20707 }
20708 {
20709 PyThreadState* __tstate = wxPyBeginAllowThreads();
20710 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20711
20712 wxPyEndAllowThreads(__tstate);
20713 if (PyErr_Occurred()) SWIG_fail;
20714 }
20715 {
20716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20717 }
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20725 PyObject *resultobj;
20726 wxDateTime *arg1 = (wxDateTime *) 0 ;
20727 wxDateTime::WeekDay arg2 ;
20728 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20729 int arg4 = (int) wxDateTime::Inv_Year ;
20730 wxDateTime result;
20731 PyObject * obj0 = 0 ;
20732 PyObject * obj1 = 0 ;
20733 PyObject * obj2 = 0 ;
20734 PyObject * obj3 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20741 if (SWIG_arg_fail(1)) SWIG_fail;
20742 {
20743 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20744 if (SWIG_arg_fail(2)) SWIG_fail;
20745 }
20746 if (obj2) {
20747 {
20748 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20749 if (SWIG_arg_fail(3)) SWIG_fail;
20750 }
20751 }
20752 if (obj3) {
20753 {
20754 arg4 = (int)(SWIG_As_int(obj3));
20755 if (SWIG_arg_fail(4)) SWIG_fail;
20756 }
20757 }
20758 {
20759 PyThreadState* __tstate = wxPyBeginAllowThreads();
20760 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20761
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 {
20766 wxDateTime * resultptr;
20767 resultptr = new wxDateTime((wxDateTime &)(result));
20768 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20769 }
20770 return resultobj;
20771 fail:
20772 return NULL;
20773 }
20774
20775
20776 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20777 PyObject *resultobj;
20778 wxDateTime *arg1 = (wxDateTime *) 0 ;
20779 int arg2 ;
20780 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20781 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20782 bool result;
20783 PyObject * obj0 = 0 ;
20784 PyObject * obj1 = 0 ;
20785 PyObject * obj2 = 0 ;
20786 PyObject * obj3 = 0 ;
20787 char *kwnames[] = {
20788 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20789 };
20790
20791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20793 if (SWIG_arg_fail(1)) SWIG_fail;
20794 {
20795 arg2 = (int)(SWIG_As_int(obj1));
20796 if (SWIG_arg_fail(2)) SWIG_fail;
20797 }
20798 if (obj2) {
20799 {
20800 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20801 if (SWIG_arg_fail(3)) SWIG_fail;
20802 }
20803 }
20804 if (obj3) {
20805 {
20806 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20807 if (SWIG_arg_fail(4)) SWIG_fail;
20808 }
20809 }
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 {
20818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20819 }
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20827 PyObject *resultobj;
20828 wxDateTime *arg1 = (wxDateTime *) 0 ;
20829 int arg2 ;
20830 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20831 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20832 wxDateTime result;
20833 PyObject * obj0 = 0 ;
20834 PyObject * obj1 = 0 ;
20835 PyObject * obj2 = 0 ;
20836 PyObject * obj3 = 0 ;
20837 char *kwnames[] = {
20838 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20839 };
20840
20841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20843 if (SWIG_arg_fail(1)) SWIG_fail;
20844 {
20845 arg2 = (int)(SWIG_As_int(obj1));
20846 if (SWIG_arg_fail(2)) SWIG_fail;
20847 }
20848 if (obj2) {
20849 {
20850 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20851 if (SWIG_arg_fail(3)) SWIG_fail;
20852 }
20853 }
20854 if (obj3) {
20855 {
20856 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20857 if (SWIG_arg_fail(4)) SWIG_fail;
20858 }
20859 }
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 wxDateTime * resultptr;
20869 resultptr = new wxDateTime((wxDateTime &)(result));
20870 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20871 }
20872 return resultobj;
20873 fail:
20874 return NULL;
20875 }
20876
20877
20878 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20879 PyObject *resultobj;
20880 int arg1 ;
20881 int arg2 ;
20882 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20883 wxDateTime result;
20884 PyObject * obj0 = 0 ;
20885 PyObject * obj1 = 0 ;
20886 PyObject * obj2 = 0 ;
20887 char *kwnames[] = {
20888 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20889 };
20890
20891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20892 {
20893 arg1 = (int)(SWIG_As_int(obj0));
20894 if (SWIG_arg_fail(1)) SWIG_fail;
20895 }
20896 {
20897 arg2 = (int)(SWIG_As_int(obj1));
20898 if (SWIG_arg_fail(2)) SWIG_fail;
20899 }
20900 if (obj2) {
20901 {
20902 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20903 if (SWIG_arg_fail(3)) SWIG_fail;
20904 }
20905 }
20906 {
20907 PyThreadState* __tstate = wxPyBeginAllowThreads();
20908 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20909
20910 wxPyEndAllowThreads(__tstate);
20911 if (PyErr_Occurred()) SWIG_fail;
20912 }
20913 {
20914 wxDateTime * resultptr;
20915 resultptr = new wxDateTime((wxDateTime &)(result));
20916 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj;
20926 wxDateTime *arg1 = (wxDateTime *) 0 ;
20927 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20928 int arg3 = (int) wxDateTime::Inv_Year ;
20929 wxDateTime *result;
20930 PyObject * obj0 = 0 ;
20931 PyObject * obj1 = 0 ;
20932 PyObject * obj2 = 0 ;
20933 char *kwnames[] = {
20934 (char *) "self",(char *) "month",(char *) "year", NULL
20935 };
20936
20937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20939 if (SWIG_arg_fail(1)) SWIG_fail;
20940 if (obj1) {
20941 {
20942 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20943 if (SWIG_arg_fail(2)) SWIG_fail;
20944 }
20945 }
20946 if (obj2) {
20947 {
20948 arg3 = (int)(SWIG_As_int(obj2));
20949 if (SWIG_arg_fail(3)) SWIG_fail;
20950 }
20951 }
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 {
20955 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20956 result = (wxDateTime *) &_result_ref;
20957 }
20958
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20963 return resultobj;
20964 fail:
20965 return NULL;
20966 }
20967
20968
20969 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20970 PyObject *resultobj;
20971 wxDateTime *arg1 = (wxDateTime *) 0 ;
20972 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20973 int arg3 = (int) wxDateTime::Inv_Year ;
20974 wxDateTime result;
20975 PyObject * obj0 = 0 ;
20976 PyObject * obj1 = 0 ;
20977 PyObject * obj2 = 0 ;
20978 char *kwnames[] = {
20979 (char *) "self",(char *) "month",(char *) "year", NULL
20980 };
20981
20982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20984 if (SWIG_arg_fail(1)) SWIG_fail;
20985 if (obj1) {
20986 {
20987 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20988 if (SWIG_arg_fail(2)) SWIG_fail;
20989 }
20990 }
20991 if (obj2) {
20992 {
20993 arg3 = (int)(SWIG_As_int(obj2));
20994 if (SWIG_arg_fail(3)) SWIG_fail;
20995 }
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
21000
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 {
21005 wxDateTime * resultptr;
21006 resultptr = new wxDateTime((wxDateTime &)(result));
21007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21008 }
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21016 PyObject *resultobj;
21017 wxDateTime *arg1 = (wxDateTime *) 0 ;
21018 int arg2 ;
21019 wxDateTime *result;
21020 PyObject * obj0 = 0 ;
21021 PyObject * obj1 = 0 ;
21022 char *kwnames[] = {
21023 (char *) "self",(char *) "yday", NULL
21024 };
21025
21026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
21027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 {
21030 arg2 = (int)(SWIG_As_int(obj1));
21031 if (SWIG_arg_fail(2)) SWIG_fail;
21032 }
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 {
21036 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
21037 result = (wxDateTime *) &_result_ref;
21038 }
21039
21040 wxPyEndAllowThreads(__tstate);
21041 if (PyErr_Occurred()) SWIG_fail;
21042 }
21043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21044 return resultobj;
21045 fail:
21046 return NULL;
21047 }
21048
21049
21050 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
21051 PyObject *resultobj;
21052 wxDateTime *arg1 = (wxDateTime *) 0 ;
21053 int arg2 ;
21054 wxDateTime result;
21055 PyObject * obj0 = 0 ;
21056 PyObject * obj1 = 0 ;
21057 char *kwnames[] = {
21058 (char *) "self",(char *) "yday", NULL
21059 };
21060
21061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21063 if (SWIG_arg_fail(1)) SWIG_fail;
21064 {
21065 arg2 = (int)(SWIG_As_int(obj1));
21066 if (SWIG_arg_fail(2)) SWIG_fail;
21067 }
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (arg1)->GetYearDay(arg2);
21071
21072 wxPyEndAllowThreads(__tstate);
21073 if (PyErr_Occurred()) SWIG_fail;
21074 }
21075 {
21076 wxDateTime * resultptr;
21077 resultptr = new wxDateTime((wxDateTime &)(result));
21078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21079 }
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxDateTime *arg1 = (wxDateTime *) 0 ;
21089 double result;
21090 PyObject * obj0 = 0 ;
21091 char *kwnames[] = {
21092 (char *) "self", NULL
21093 };
21094
21095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21097 if (SWIG_arg_fail(1)) SWIG_fail;
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (double)(arg1)->GetJulianDayNumber();
21101
21102 wxPyEndAllowThreads(__tstate);
21103 if (PyErr_Occurred()) SWIG_fail;
21104 }
21105 {
21106 resultobj = SWIG_From_double((double)(result));
21107 }
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 wxDateTime *arg1 = (wxDateTime *) 0 ;
21117 double result;
21118 PyObject * obj0 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 result = (double)(arg1)->GetJDN();
21129
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 {
21134 resultobj = SWIG_From_double((double)(result));
21135 }
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxDateTime *arg1 = (wxDateTime *) 0 ;
21145 double result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = SWIG_From_double((double)(result));
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxDateTime *arg1 = (wxDateTime *) 0 ;
21173 double result;
21174 PyObject * obj0 = 0 ;
21175 char *kwnames[] = {
21176 (char *) "self", NULL
21177 };
21178
21179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21181 if (SWIG_arg_fail(1)) SWIG_fail;
21182 {
21183 PyThreadState* __tstate = wxPyBeginAllowThreads();
21184 result = (double)(arg1)->GetMJD();
21185
21186 wxPyEndAllowThreads(__tstate);
21187 if (PyErr_Occurred()) SWIG_fail;
21188 }
21189 {
21190 resultobj = SWIG_From_double((double)(result));
21191 }
21192 return resultobj;
21193 fail:
21194 return NULL;
21195 }
21196
21197
21198 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21199 PyObject *resultobj;
21200 wxDateTime *arg1 = (wxDateTime *) 0 ;
21201 double result;
21202 PyObject * obj0 = 0 ;
21203 char *kwnames[] = {
21204 (char *) "self", NULL
21205 };
21206
21207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21209 if (SWIG_arg_fail(1)) SWIG_fail;
21210 {
21211 PyThreadState* __tstate = wxPyBeginAllowThreads();
21212 result = (double)(arg1)->GetRataDie();
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 {
21218 resultobj = SWIG_From_double((double)(result));
21219 }
21220 return resultobj;
21221 fail:
21222 return NULL;
21223 }
21224
21225
21226 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21227 PyObject *resultobj;
21228 wxDateTime *arg1 = (wxDateTime *) 0 ;
21229 wxDateTime::TimeZone *arg2 = 0 ;
21230 bool arg3 = (bool) false ;
21231 wxDateTime result;
21232 bool temp2 = false ;
21233 PyObject * obj0 = 0 ;
21234 PyObject * obj1 = 0 ;
21235 PyObject * obj2 = 0 ;
21236 char *kwnames[] = {
21237 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21238 };
21239
21240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21242 if (SWIG_arg_fail(1)) SWIG_fail;
21243 {
21244 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21245 temp2 = true;
21246 }
21247 if (obj2) {
21248 {
21249 arg3 = (bool)(SWIG_As_bool(obj2));
21250 if (SWIG_arg_fail(3)) SWIG_fail;
21251 }
21252 }
21253 {
21254 PyThreadState* __tstate = wxPyBeginAllowThreads();
21255 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21256
21257 wxPyEndAllowThreads(__tstate);
21258 if (PyErr_Occurred()) SWIG_fail;
21259 }
21260 {
21261 wxDateTime * resultptr;
21262 resultptr = new wxDateTime((wxDateTime &)(result));
21263 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21264 }
21265 {
21266 if (temp2) delete arg2;
21267 }
21268 return resultobj;
21269 fail:
21270 {
21271 if (temp2) delete arg2;
21272 }
21273 return NULL;
21274 }
21275
21276
21277 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj;
21279 wxDateTime *arg1 = (wxDateTime *) 0 ;
21280 wxDateTime::TimeZone *arg2 = 0 ;
21281 bool arg3 = (bool) false ;
21282 wxDateTime *result;
21283 bool temp2 = false ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 PyObject * obj2 = 0 ;
21287 char *kwnames[] = {
21288 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21289 };
21290
21291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(1)) SWIG_fail;
21294 {
21295 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21296 temp2 = true;
21297 }
21298 if (obj2) {
21299 {
21300 arg3 = (bool)(SWIG_As_bool(obj2));
21301 if (SWIG_arg_fail(3)) SWIG_fail;
21302 }
21303 }
21304 {
21305 PyThreadState* __tstate = wxPyBeginAllowThreads();
21306 {
21307 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21308 result = (wxDateTime *) &_result_ref;
21309 }
21310
21311 wxPyEndAllowThreads(__tstate);
21312 if (PyErr_Occurred()) SWIG_fail;
21313 }
21314 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21315 {
21316 if (temp2) delete arg2;
21317 }
21318 return resultobj;
21319 fail:
21320 {
21321 if (temp2) delete arg2;
21322 }
21323 return NULL;
21324 }
21325
21326
21327 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21328 PyObject *resultobj;
21329 wxDateTime *arg1 = (wxDateTime *) 0 ;
21330 bool arg2 = (bool) false ;
21331 wxDateTime result;
21332 PyObject * obj0 = 0 ;
21333 PyObject * obj1 = 0 ;
21334 char *kwnames[] = {
21335 (char *) "self",(char *) "noDST", NULL
21336 };
21337
21338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21340 if (SWIG_arg_fail(1)) SWIG_fail;
21341 if (obj1) {
21342 {
21343 arg2 = (bool)(SWIG_As_bool(obj1));
21344 if (SWIG_arg_fail(2)) SWIG_fail;
21345 }
21346 }
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (arg1)->ToGMT(arg2);
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 {
21355 wxDateTime * resultptr;
21356 resultptr = new wxDateTime((wxDateTime &)(result));
21357 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21358 }
21359 return resultobj;
21360 fail:
21361 return NULL;
21362 }
21363
21364
21365 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21366 PyObject *resultobj;
21367 wxDateTime *arg1 = (wxDateTime *) 0 ;
21368 bool arg2 = (bool) false ;
21369 wxDateTime *result;
21370 PyObject * obj0 = 0 ;
21371 PyObject * obj1 = 0 ;
21372 char *kwnames[] = {
21373 (char *) "self",(char *) "noDST", NULL
21374 };
21375
21376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21378 if (SWIG_arg_fail(1)) SWIG_fail;
21379 if (obj1) {
21380 {
21381 arg2 = (bool)(SWIG_As_bool(obj1));
21382 if (SWIG_arg_fail(2)) SWIG_fail;
21383 }
21384 }
21385 {
21386 PyThreadState* __tstate = wxPyBeginAllowThreads();
21387 {
21388 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21389 result = (wxDateTime *) &_result_ref;
21390 }
21391
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21396 return resultobj;
21397 fail:
21398 return NULL;
21399 }
21400
21401
21402 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21403 PyObject *resultobj;
21404 wxDateTime *arg1 = (wxDateTime *) 0 ;
21405 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21406 int result;
21407 PyObject * obj0 = 0 ;
21408 PyObject * obj1 = 0 ;
21409 char *kwnames[] = {
21410 (char *) "self",(char *) "country", NULL
21411 };
21412
21413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21415 if (SWIG_arg_fail(1)) SWIG_fail;
21416 if (obj1) {
21417 {
21418 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21419 if (SWIG_arg_fail(2)) SWIG_fail;
21420 }
21421 }
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21425
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 {
21430 resultobj = SWIG_From_int((int)(result));
21431 }
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj;
21440 wxDateTime *arg1 = (wxDateTime *) 0 ;
21441 bool result;
21442 PyObject * obj0 = 0 ;
21443 char *kwnames[] = {
21444 (char *) "self", NULL
21445 };
21446
21447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21449 if (SWIG_arg_fail(1)) SWIG_fail;
21450 {
21451 PyThreadState* __tstate = wxPyBeginAllowThreads();
21452 result = (bool)((wxDateTime const *)arg1)->IsValid();
21453
21454 wxPyEndAllowThreads(__tstate);
21455 if (PyErr_Occurred()) SWIG_fail;
21456 }
21457 {
21458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21459 }
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21467 PyObject *resultobj;
21468 wxDateTime *arg1 = (wxDateTime *) 0 ;
21469 time_t result;
21470 PyObject * obj0 = 0 ;
21471 char *kwnames[] = {
21472 (char *) "self", NULL
21473 };
21474
21475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21477 if (SWIG_arg_fail(1)) SWIG_fail;
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21481
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 {
21486 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21487 }
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj;
21496 wxDateTime *arg1 = (wxDateTime *) 0 ;
21497 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21498 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21499 int result;
21500 bool temp2 = false ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self",(char *) "tz", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 if (obj1) {
21511 {
21512 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21513 temp2 = true;
21514 }
21515 }
21516 {
21517 PyThreadState* __tstate = wxPyBeginAllowThreads();
21518 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21519
21520 wxPyEndAllowThreads(__tstate);
21521 if (PyErr_Occurred()) SWIG_fail;
21522 }
21523 {
21524 resultobj = SWIG_From_int((int)(result));
21525 }
21526 {
21527 if (temp2) delete arg2;
21528 }
21529 return resultobj;
21530 fail:
21531 {
21532 if (temp2) delete arg2;
21533 }
21534 return NULL;
21535 }
21536
21537
21538 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21539 PyObject *resultobj;
21540 wxDateTime *arg1 = (wxDateTime *) 0 ;
21541 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21542 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21543 wxDateTime::Month result;
21544 bool temp2 = false ;
21545 PyObject * obj0 = 0 ;
21546 PyObject * obj1 = 0 ;
21547 char *kwnames[] = {
21548 (char *) "self",(char *) "tz", NULL
21549 };
21550
21551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21553 if (SWIG_arg_fail(1)) SWIG_fail;
21554 if (obj1) {
21555 {
21556 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21557 temp2 = true;
21558 }
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21563
21564 wxPyEndAllowThreads(__tstate);
21565 if (PyErr_Occurred()) SWIG_fail;
21566 }
21567 resultobj = SWIG_From_int((result));
21568 {
21569 if (temp2) delete arg2;
21570 }
21571 return resultobj;
21572 fail:
21573 {
21574 if (temp2) delete arg2;
21575 }
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxDateTime *arg1 = (wxDateTime *) 0 ;
21583 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21584 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21585 int result;
21586 bool temp2 = false ;
21587 PyObject * obj0 = 0 ;
21588 PyObject * obj1 = 0 ;
21589 char *kwnames[] = {
21590 (char *) "self",(char *) "tz", NULL
21591 };
21592
21593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21595 if (SWIG_arg_fail(1)) SWIG_fail;
21596 if (obj1) {
21597 {
21598 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21599 temp2 = true;
21600 }
21601 }
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21605
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 {
21610 resultobj = SWIG_From_int((int)(result));
21611 }
21612 {
21613 if (temp2) delete arg2;
21614 }
21615 return resultobj;
21616 fail:
21617 {
21618 if (temp2) delete arg2;
21619 }
21620 return NULL;
21621 }
21622
21623
21624 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21625 PyObject *resultobj;
21626 wxDateTime *arg1 = (wxDateTime *) 0 ;
21627 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21628 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21629 wxDateTime::WeekDay result;
21630 bool temp2 = false ;
21631 PyObject * obj0 = 0 ;
21632 PyObject * obj1 = 0 ;
21633 char *kwnames[] = {
21634 (char *) "self",(char *) "tz", NULL
21635 };
21636
21637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21639 if (SWIG_arg_fail(1)) SWIG_fail;
21640 if (obj1) {
21641 {
21642 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21643 temp2 = true;
21644 }
21645 }
21646 {
21647 PyThreadState* __tstate = wxPyBeginAllowThreads();
21648 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21649
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_From_int((result));
21654 {
21655 if (temp2) delete arg2;
21656 }
21657 return resultobj;
21658 fail:
21659 {
21660 if (temp2) delete arg2;
21661 }
21662 return NULL;
21663 }
21664
21665
21666 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21667 PyObject *resultobj;
21668 wxDateTime *arg1 = (wxDateTime *) 0 ;
21669 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21670 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21671 int result;
21672 bool temp2 = false ;
21673 PyObject * obj0 = 0 ;
21674 PyObject * obj1 = 0 ;
21675 char *kwnames[] = {
21676 (char *) "self",(char *) "tz", NULL
21677 };
21678
21679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21681 if (SWIG_arg_fail(1)) SWIG_fail;
21682 if (obj1) {
21683 {
21684 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21685 temp2 = true;
21686 }
21687 }
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21691
21692 wxPyEndAllowThreads(__tstate);
21693 if (PyErr_Occurred()) SWIG_fail;
21694 }
21695 {
21696 resultobj = SWIG_From_int((int)(result));
21697 }
21698 {
21699 if (temp2) delete arg2;
21700 }
21701 return resultobj;
21702 fail:
21703 {
21704 if (temp2) delete arg2;
21705 }
21706 return NULL;
21707 }
21708
21709
21710 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21711 PyObject *resultobj;
21712 wxDateTime *arg1 = (wxDateTime *) 0 ;
21713 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21714 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21715 int result;
21716 bool temp2 = false ;
21717 PyObject * obj0 = 0 ;
21718 PyObject * obj1 = 0 ;
21719 char *kwnames[] = {
21720 (char *) "self",(char *) "tz", NULL
21721 };
21722
21723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21725 if (SWIG_arg_fail(1)) SWIG_fail;
21726 if (obj1) {
21727 {
21728 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21729 temp2 = true;
21730 }
21731 }
21732 {
21733 PyThreadState* __tstate = wxPyBeginAllowThreads();
21734 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21735
21736 wxPyEndAllowThreads(__tstate);
21737 if (PyErr_Occurred()) SWIG_fail;
21738 }
21739 {
21740 resultobj = SWIG_From_int((int)(result));
21741 }
21742 {
21743 if (temp2) delete arg2;
21744 }
21745 return resultobj;
21746 fail:
21747 {
21748 if (temp2) delete arg2;
21749 }
21750 return NULL;
21751 }
21752
21753
21754 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21755 PyObject *resultobj;
21756 wxDateTime *arg1 = (wxDateTime *) 0 ;
21757 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21758 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21759 int result;
21760 bool temp2 = false ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char *kwnames[] = {
21764 (char *) "self",(char *) "tz", NULL
21765 };
21766
21767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21769 if (SWIG_arg_fail(1)) SWIG_fail;
21770 if (obj1) {
21771 {
21772 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21773 temp2 = true;
21774 }
21775 }
21776 {
21777 PyThreadState* __tstate = wxPyBeginAllowThreads();
21778 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21779
21780 wxPyEndAllowThreads(__tstate);
21781 if (PyErr_Occurred()) SWIG_fail;
21782 }
21783 {
21784 resultobj = SWIG_From_int((int)(result));
21785 }
21786 {
21787 if (temp2) delete arg2;
21788 }
21789 return resultobj;
21790 fail:
21791 {
21792 if (temp2) delete arg2;
21793 }
21794 return NULL;
21795 }
21796
21797
21798 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21799 PyObject *resultobj;
21800 wxDateTime *arg1 = (wxDateTime *) 0 ;
21801 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21802 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21803 int result;
21804 bool temp2 = false ;
21805 PyObject * obj0 = 0 ;
21806 PyObject * obj1 = 0 ;
21807 char *kwnames[] = {
21808 (char *) "self",(char *) "tz", NULL
21809 };
21810
21811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21813 if (SWIG_arg_fail(1)) SWIG_fail;
21814 if (obj1) {
21815 {
21816 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21817 temp2 = true;
21818 }
21819 }
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21823
21824 wxPyEndAllowThreads(__tstate);
21825 if (PyErr_Occurred()) SWIG_fail;
21826 }
21827 {
21828 resultobj = SWIG_From_int((int)(result));
21829 }
21830 {
21831 if (temp2) delete arg2;
21832 }
21833 return resultobj;
21834 fail:
21835 {
21836 if (temp2) delete arg2;
21837 }
21838 return NULL;
21839 }
21840
21841
21842 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21843 PyObject *resultobj;
21844 wxDateTime *arg1 = (wxDateTime *) 0 ;
21845 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21846 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21847 int result;
21848 bool temp2 = false ;
21849 PyObject * obj0 = 0 ;
21850 PyObject * obj1 = 0 ;
21851 char *kwnames[] = {
21852 (char *) "self",(char *) "tz", NULL
21853 };
21854
21855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21857 if (SWIG_arg_fail(1)) SWIG_fail;
21858 if (obj1) {
21859 {
21860 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21861 temp2 = true;
21862 }
21863 }
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21867
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 resultobj = SWIG_From_int((int)(result));
21873 }
21874 {
21875 if (temp2) delete arg2;
21876 }
21877 return resultobj;
21878 fail:
21879 {
21880 if (temp2) delete arg2;
21881 }
21882 return NULL;
21883 }
21884
21885
21886 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21887 PyObject *resultobj;
21888 wxDateTime *arg1 = (wxDateTime *) 0 ;
21889 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21890 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21891 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21892 int result;
21893 bool temp3 = false ;
21894 PyObject * obj0 = 0 ;
21895 PyObject * obj1 = 0 ;
21896 PyObject * obj2 = 0 ;
21897 char *kwnames[] = {
21898 (char *) "self",(char *) "flags",(char *) "tz", NULL
21899 };
21900
21901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21903 if (SWIG_arg_fail(1)) SWIG_fail;
21904 if (obj1) {
21905 {
21906 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21907 if (SWIG_arg_fail(2)) SWIG_fail;
21908 }
21909 }
21910 if (obj2) {
21911 {
21912 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21913 temp3 = true;
21914 }
21915 }
21916 {
21917 PyThreadState* __tstate = wxPyBeginAllowThreads();
21918 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21919
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 {
21924 resultobj = SWIG_From_int((int)(result));
21925 }
21926 {
21927 if (temp3) delete arg3;
21928 }
21929 return resultobj;
21930 fail:
21931 {
21932 if (temp3) delete arg3;
21933 }
21934 return NULL;
21935 }
21936
21937
21938 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21939 PyObject *resultobj;
21940 wxDateTime *arg1 = (wxDateTime *) 0 ;
21941 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21942 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21943 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21944 int result;
21945 bool temp3 = false ;
21946 PyObject * obj0 = 0 ;
21947 PyObject * obj1 = 0 ;
21948 PyObject * obj2 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self",(char *) "flags",(char *) "tz", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 if (obj1) {
21957 {
21958 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21959 if (SWIG_arg_fail(2)) SWIG_fail;
21960 }
21961 }
21962 if (obj2) {
21963 {
21964 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21965 temp3 = true;
21966 }
21967 }
21968 {
21969 PyThreadState* __tstate = wxPyBeginAllowThreads();
21970 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21971
21972 wxPyEndAllowThreads(__tstate);
21973 if (PyErr_Occurred()) SWIG_fail;
21974 }
21975 {
21976 resultobj = SWIG_From_int((int)(result));
21977 }
21978 {
21979 if (temp3) delete arg3;
21980 }
21981 return resultobj;
21982 fail:
21983 {
21984 if (temp3) delete arg3;
21985 }
21986 return NULL;
21987 }
21988
21989
21990 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21991 PyObject *resultobj;
21992 wxDateTime *arg1 = (wxDateTime *) 0 ;
21993 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21994 bool result;
21995 PyObject * obj0 = 0 ;
21996 PyObject * obj1 = 0 ;
21997 char *kwnames[] = {
21998 (char *) "self",(char *) "country", NULL
21999 };
22000
22001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
22002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22003 if (SWIG_arg_fail(1)) SWIG_fail;
22004 if (obj1) {
22005 {
22006 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
22007 if (SWIG_arg_fail(2)) SWIG_fail;
22008 }
22009 }
22010 {
22011 PyThreadState* __tstate = wxPyBeginAllowThreads();
22012 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
22013
22014 wxPyEndAllowThreads(__tstate);
22015 if (PyErr_Occurred()) SWIG_fail;
22016 }
22017 {
22018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22019 }
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxDateTime *arg1 = (wxDateTime *) 0 ;
22029 wxDateTime *arg2 = 0 ;
22030 bool result;
22031 PyObject * obj0 = 0 ;
22032 PyObject * obj1 = 0 ;
22033 char *kwnames[] = {
22034 (char *) "self",(char *) "datetime", NULL
22035 };
22036
22037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",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 {
22041 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22042 if (SWIG_arg_fail(2)) SWIG_fail;
22043 if (arg2 == NULL) {
22044 SWIG_null_ref("wxDateTime");
22045 }
22046 if (SWIG_arg_fail(2)) SWIG_fail;
22047 }
22048 {
22049 PyThreadState* __tstate = wxPyBeginAllowThreads();
22050 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
22051
22052 wxPyEndAllowThreads(__tstate);
22053 if (PyErr_Occurred()) SWIG_fail;
22054 }
22055 {
22056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22057 }
22058 return resultobj;
22059 fail:
22060 return NULL;
22061 }
22062
22063
22064 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22065 PyObject *resultobj;
22066 wxDateTime *arg1 = (wxDateTime *) 0 ;
22067 wxDateTime *arg2 = 0 ;
22068 bool result;
22069 PyObject * obj0 = 0 ;
22070 PyObject * obj1 = 0 ;
22071 char *kwnames[] = {
22072 (char *) "self",(char *) "datetime", NULL
22073 };
22074
22075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22077 if (SWIG_arg_fail(1)) SWIG_fail;
22078 {
22079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(2)) SWIG_fail;
22081 if (arg2 == NULL) {
22082 SWIG_null_ref("wxDateTime");
22083 }
22084 if (SWIG_arg_fail(2)) SWIG_fail;
22085 }
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22089
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 {
22094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22095 }
22096 return resultobj;
22097 fail:
22098 return NULL;
22099 }
22100
22101
22102 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxDateTime *arg1 = (wxDateTime *) 0 ;
22105 wxDateTime *arg2 = 0 ;
22106 bool result;
22107 PyObject * obj0 = 0 ;
22108 PyObject * obj1 = 0 ;
22109 char *kwnames[] = {
22110 (char *) "self",(char *) "datetime", NULL
22111 };
22112
22113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22115 if (SWIG_arg_fail(1)) SWIG_fail;
22116 {
22117 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22118 if (SWIG_arg_fail(2)) SWIG_fail;
22119 if (arg2 == NULL) {
22120 SWIG_null_ref("wxDateTime");
22121 }
22122 if (SWIG_arg_fail(2)) SWIG_fail;
22123 }
22124 {
22125 PyThreadState* __tstate = wxPyBeginAllowThreads();
22126 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22127
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 {
22132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22133 }
22134 return resultobj;
22135 fail:
22136 return NULL;
22137 }
22138
22139
22140 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22141 PyObject *resultobj;
22142 wxDateTime *arg1 = (wxDateTime *) 0 ;
22143 wxDateTime *arg2 = 0 ;
22144 wxDateTime *arg3 = 0 ;
22145 bool result;
22146 PyObject * obj0 = 0 ;
22147 PyObject * obj1 = 0 ;
22148 PyObject * obj2 = 0 ;
22149 char *kwnames[] = {
22150 (char *) "self",(char *) "t1",(char *) "t2", NULL
22151 };
22152
22153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(1)) SWIG_fail;
22156 {
22157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(2)) SWIG_fail;
22159 if (arg2 == NULL) {
22160 SWIG_null_ref("wxDateTime");
22161 }
22162 if (SWIG_arg_fail(2)) SWIG_fail;
22163 }
22164 {
22165 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22166 if (SWIG_arg_fail(3)) SWIG_fail;
22167 if (arg3 == NULL) {
22168 SWIG_null_ref("wxDateTime");
22169 }
22170 if (SWIG_arg_fail(3)) SWIG_fail;
22171 }
22172 {
22173 PyThreadState* __tstate = wxPyBeginAllowThreads();
22174 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22175
22176 wxPyEndAllowThreads(__tstate);
22177 if (PyErr_Occurred()) SWIG_fail;
22178 }
22179 {
22180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22181 }
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxDateTime *arg1 = (wxDateTime *) 0 ;
22191 wxDateTime *arg2 = 0 ;
22192 wxDateTime *arg3 = 0 ;
22193 bool result;
22194 PyObject * obj0 = 0 ;
22195 PyObject * obj1 = 0 ;
22196 PyObject * obj2 = 0 ;
22197 char *kwnames[] = {
22198 (char *) "self",(char *) "t1",(char *) "t2", NULL
22199 };
22200
22201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22203 if (SWIG_arg_fail(1)) SWIG_fail;
22204 {
22205 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22206 if (SWIG_arg_fail(2)) SWIG_fail;
22207 if (arg2 == NULL) {
22208 SWIG_null_ref("wxDateTime");
22209 }
22210 if (SWIG_arg_fail(2)) SWIG_fail;
22211 }
22212 {
22213 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22214 if (SWIG_arg_fail(3)) SWIG_fail;
22215 if (arg3 == NULL) {
22216 SWIG_null_ref("wxDateTime");
22217 }
22218 if (SWIG_arg_fail(3)) SWIG_fail;
22219 }
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22223
22224 wxPyEndAllowThreads(__tstate);
22225 if (PyErr_Occurred()) SWIG_fail;
22226 }
22227 {
22228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22229 }
22230 return resultobj;
22231 fail:
22232 return NULL;
22233 }
22234
22235
22236 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22237 PyObject *resultobj;
22238 wxDateTime *arg1 = (wxDateTime *) 0 ;
22239 wxDateTime *arg2 = 0 ;
22240 bool result;
22241 PyObject * obj0 = 0 ;
22242 PyObject * obj1 = 0 ;
22243 char *kwnames[] = {
22244 (char *) "self",(char *) "dt", NULL
22245 };
22246
22247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22249 if (SWIG_arg_fail(1)) SWIG_fail;
22250 {
22251 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22252 if (SWIG_arg_fail(2)) SWIG_fail;
22253 if (arg2 == NULL) {
22254 SWIG_null_ref("wxDateTime");
22255 }
22256 if (SWIG_arg_fail(2)) SWIG_fail;
22257 }
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22261
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 {
22266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22267 }
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj;
22276 wxDateTime *arg1 = (wxDateTime *) 0 ;
22277 wxDateTime *arg2 = 0 ;
22278 bool result;
22279 PyObject * obj0 = 0 ;
22280 PyObject * obj1 = 0 ;
22281 char *kwnames[] = {
22282 (char *) "self",(char *) "dt", NULL
22283 };
22284
22285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22287 if (SWIG_arg_fail(1)) SWIG_fail;
22288 {
22289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(2)) SWIG_fail;
22291 if (arg2 == NULL) {
22292 SWIG_null_ref("wxDateTime");
22293 }
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22299
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 {
22304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22305 }
22306 return resultobj;
22307 fail:
22308 return NULL;
22309 }
22310
22311
22312 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22313 PyObject *resultobj;
22314 wxDateTime *arg1 = (wxDateTime *) 0 ;
22315 wxDateTime *arg2 = 0 ;
22316 wxTimeSpan *arg3 = 0 ;
22317 bool result;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 PyObject * obj2 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self",(char *) "dt",(char *) "ts", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 if (arg2 == NULL) {
22332 SWIG_null_ref("wxDateTime");
22333 }
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 }
22336 {
22337 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22338 if (SWIG_arg_fail(3)) SWIG_fail;
22339 if (arg3 == NULL) {
22340 SWIG_null_ref("wxTimeSpan");
22341 }
22342 if (SWIG_arg_fail(3)) SWIG_fail;
22343 }
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22347
22348 wxPyEndAllowThreads(__tstate);
22349 if (PyErr_Occurred()) SWIG_fail;
22350 }
22351 {
22352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22353 }
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj;
22362 wxDateTime *arg1 = (wxDateTime *) 0 ;
22363 wxTimeSpan *arg2 = 0 ;
22364 wxDateTime *result;
22365 PyObject * obj0 = 0 ;
22366 PyObject * obj1 = 0 ;
22367 char *kwnames[] = {
22368 (char *) "self",(char *) "diff", NULL
22369 };
22370
22371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22373 if (SWIG_arg_fail(1)) SWIG_fail;
22374 {
22375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22376 if (SWIG_arg_fail(2)) SWIG_fail;
22377 if (arg2 == NULL) {
22378 SWIG_null_ref("wxTimeSpan");
22379 }
22380 if (SWIG_arg_fail(2)) SWIG_fail;
22381 }
22382 {
22383 PyThreadState* __tstate = wxPyBeginAllowThreads();
22384 {
22385 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22386 result = (wxDateTime *) &_result_ref;
22387 }
22388
22389 wxPyEndAllowThreads(__tstate);
22390 if (PyErr_Occurred()) SWIG_fail;
22391 }
22392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22393 return resultobj;
22394 fail:
22395 return NULL;
22396 }
22397
22398
22399 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22400 PyObject *resultobj;
22401 wxDateTime *arg1 = (wxDateTime *) 0 ;
22402 wxDateSpan *arg2 = 0 ;
22403 wxDateTime *result;
22404 PyObject * obj0 = 0 ;
22405 PyObject * obj1 = 0 ;
22406 char *kwnames[] = {
22407 (char *) "self",(char *) "diff", NULL
22408 };
22409
22410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22412 if (SWIG_arg_fail(1)) SWIG_fail;
22413 {
22414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22415 if (SWIG_arg_fail(2)) SWIG_fail;
22416 if (arg2 == NULL) {
22417 SWIG_null_ref("wxDateSpan");
22418 }
22419 if (SWIG_arg_fail(2)) SWIG_fail;
22420 }
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 {
22424 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22425 result = (wxDateTime *) &_result_ref;
22426 }
22427
22428 wxPyEndAllowThreads(__tstate);
22429 if (PyErr_Occurred()) SWIG_fail;
22430 }
22431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22432 return resultobj;
22433 fail:
22434 return NULL;
22435 }
22436
22437
22438 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22439 PyObject *resultobj;
22440 wxDateTime *arg1 = (wxDateTime *) 0 ;
22441 wxTimeSpan *arg2 = 0 ;
22442 wxDateTime *result;
22443 PyObject * obj0 = 0 ;
22444 PyObject * obj1 = 0 ;
22445 char *kwnames[] = {
22446 (char *) "self",(char *) "diff", NULL
22447 };
22448
22449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22451 if (SWIG_arg_fail(1)) SWIG_fail;
22452 {
22453 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22454 if (SWIG_arg_fail(2)) SWIG_fail;
22455 if (arg2 == NULL) {
22456 SWIG_null_ref("wxTimeSpan");
22457 }
22458 if (SWIG_arg_fail(2)) SWIG_fail;
22459 }
22460 {
22461 PyThreadState* __tstate = wxPyBeginAllowThreads();
22462 {
22463 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22464 result = (wxDateTime *) &_result_ref;
22465 }
22466
22467 wxPyEndAllowThreads(__tstate);
22468 if (PyErr_Occurred()) SWIG_fail;
22469 }
22470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22471 return resultobj;
22472 fail:
22473 return NULL;
22474 }
22475
22476
22477 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22478 PyObject *resultobj;
22479 wxDateTime *arg1 = (wxDateTime *) 0 ;
22480 wxDateSpan *arg2 = 0 ;
22481 wxDateTime *result;
22482 PyObject * obj0 = 0 ;
22483 PyObject * obj1 = 0 ;
22484 char *kwnames[] = {
22485 (char *) "self",(char *) "diff", NULL
22486 };
22487
22488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22490 if (SWIG_arg_fail(1)) SWIG_fail;
22491 {
22492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22493 if (SWIG_arg_fail(2)) SWIG_fail;
22494 if (arg2 == NULL) {
22495 SWIG_null_ref("wxDateSpan");
22496 }
22497 if (SWIG_arg_fail(2)) SWIG_fail;
22498 }
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 {
22502 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22503 result = (wxDateTime *) &_result_ref;
22504 }
22505
22506 wxPyEndAllowThreads(__tstate);
22507 if (PyErr_Occurred()) SWIG_fail;
22508 }
22509 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22510 return resultobj;
22511 fail:
22512 return NULL;
22513 }
22514
22515
22516 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22517 PyObject *resultobj;
22518 wxDateTime *arg1 = (wxDateTime *) 0 ;
22519 wxDateTime *arg2 = 0 ;
22520 wxTimeSpan result;
22521 PyObject * obj0 = 0 ;
22522 PyObject * obj1 = 0 ;
22523 char *kwnames[] = {
22524 (char *) "self",(char *) "dt", NULL
22525 };
22526
22527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22529 if (SWIG_arg_fail(1)) SWIG_fail;
22530 {
22531 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22532 if (SWIG_arg_fail(2)) SWIG_fail;
22533 if (arg2 == NULL) {
22534 SWIG_null_ref("wxDateTime");
22535 }
22536 if (SWIG_arg_fail(2)) SWIG_fail;
22537 }
22538 {
22539 PyThreadState* __tstate = wxPyBeginAllowThreads();
22540 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22541
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 {
22546 wxTimeSpan * resultptr;
22547 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22549 }
22550 return resultobj;
22551 fail:
22552 return NULL;
22553 }
22554
22555
22556 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22557 PyObject *resultobj;
22558 wxDateTime *arg1 = (wxDateTime *) 0 ;
22559 wxTimeSpan *arg2 = 0 ;
22560 wxDateTime *result;
22561 PyObject * obj0 = 0 ;
22562 PyObject * obj1 = 0 ;
22563
22564 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22566 if (SWIG_arg_fail(1)) SWIG_fail;
22567 {
22568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22569 if (SWIG_arg_fail(2)) SWIG_fail;
22570 if (arg2 == NULL) {
22571 SWIG_null_ref("wxTimeSpan");
22572 }
22573 if (SWIG_arg_fail(2)) SWIG_fail;
22574 }
22575 {
22576 PyThreadState* __tstate = wxPyBeginAllowThreads();
22577 {
22578 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22579 result = (wxDateTime *) &_result_ref;
22580 }
22581
22582 wxPyEndAllowThreads(__tstate);
22583 if (PyErr_Occurred()) SWIG_fail;
22584 }
22585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22586 return resultobj;
22587 fail:
22588 return NULL;
22589 }
22590
22591
22592 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22593 PyObject *resultobj;
22594 wxDateTime *arg1 = (wxDateTime *) 0 ;
22595 wxDateSpan *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_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22605 if (SWIG_arg_fail(2)) SWIG_fail;
22606 if (arg2 == NULL) {
22607 SWIG_null_ref("wxDateSpan");
22608 }
22609 if (SWIG_arg_fail(2)) SWIG_fail;
22610 }
22611 {
22612 PyThreadState* __tstate = wxPyBeginAllowThreads();
22613 {
22614 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan 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__(PyObject *self, PyObject *args) {
22629 int argc;
22630 PyObject *argv[3];
22631 int ii;
22632
22633 argc = PyObject_Length(args);
22634 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22635 argv[ii] = PyTuple_GetItem(args,ii);
22636 }
22637 if (argc == 2) {
22638 int _v;
22639 {
22640 void *ptr;
22641 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22642 _v = 0;
22643 PyErr_Clear();
22644 } else {
22645 _v = 1;
22646 }
22647 }
22648 if (_v) {
22649 {
22650 void *ptr = 0;
22651 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22652 _v = 0;
22653 PyErr_Clear();
22654 } else {
22655 _v = (ptr != 0);
22656 }
22657 }
22658 if (_v) {
22659 return _wrap_DateTime___iadd____SWIG_0(self,args);
22660 }
22661 }
22662 }
22663 if (argc == 2) {
22664 int _v;
22665 {
22666 void *ptr;
22667 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22668 _v = 0;
22669 PyErr_Clear();
22670 } else {
22671 _v = 1;
22672 }
22673 }
22674 if (_v) {
22675 {
22676 void *ptr = 0;
22677 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22678 _v = 0;
22679 PyErr_Clear();
22680 } else {
22681 _v = (ptr != 0);
22682 }
22683 }
22684 if (_v) {
22685 return _wrap_DateTime___iadd____SWIG_1(self,args);
22686 }
22687 }
22688 }
22689
22690 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22691 return NULL;
22692 }
22693
22694
22695 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22696 PyObject *resultobj;
22697 wxDateTime *arg1 = (wxDateTime *) 0 ;
22698 wxTimeSpan *arg2 = 0 ;
22699 wxDateTime *result;
22700 PyObject * obj0 = 0 ;
22701 PyObject * obj1 = 0 ;
22702
22703 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22705 if (SWIG_arg_fail(1)) SWIG_fail;
22706 {
22707 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22708 if (SWIG_arg_fail(2)) SWIG_fail;
22709 if (arg2 == NULL) {
22710 SWIG_null_ref("wxTimeSpan");
22711 }
22712 if (SWIG_arg_fail(2)) SWIG_fail;
22713 }
22714 {
22715 PyThreadState* __tstate = wxPyBeginAllowThreads();
22716 {
22717 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22718 result = (wxDateTime *) &_result_ref;
22719 }
22720
22721 wxPyEndAllowThreads(__tstate);
22722 if (PyErr_Occurred()) SWIG_fail;
22723 }
22724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22725 return resultobj;
22726 fail:
22727 return NULL;
22728 }
22729
22730
22731 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22732 PyObject *resultobj;
22733 wxDateTime *arg1 = (wxDateTime *) 0 ;
22734 wxDateSpan *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_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22744 if (SWIG_arg_fail(2)) SWIG_fail;
22745 if (arg2 == NULL) {
22746 SWIG_null_ref("wxDateSpan");
22747 }
22748 if (SWIG_arg_fail(2)) SWIG_fail;
22749 }
22750 {
22751 PyThreadState* __tstate = wxPyBeginAllowThreads();
22752 {
22753 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan 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__(PyObject *self, PyObject *args) {
22768 int argc;
22769 PyObject *argv[3];
22770 int ii;
22771
22772 argc = PyObject_Length(args);
22773 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22774 argv[ii] = PyTuple_GetItem(args,ii);
22775 }
22776 if (argc == 2) {
22777 int _v;
22778 {
22779 void *ptr;
22780 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22781 _v = 0;
22782 PyErr_Clear();
22783 } else {
22784 _v = 1;
22785 }
22786 }
22787 if (_v) {
22788 {
22789 void *ptr = 0;
22790 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22791 _v = 0;
22792 PyErr_Clear();
22793 } else {
22794 _v = (ptr != 0);
22795 }
22796 }
22797 if (_v) {
22798 return _wrap_DateTime___isub____SWIG_0(self,args);
22799 }
22800 }
22801 }
22802 if (argc == 2) {
22803 int _v;
22804 {
22805 void *ptr;
22806 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22807 _v = 0;
22808 PyErr_Clear();
22809 } else {
22810 _v = 1;
22811 }
22812 }
22813 if (_v) {
22814 {
22815 void *ptr = 0;
22816 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22817 _v = 0;
22818 PyErr_Clear();
22819 } else {
22820 _v = (ptr != 0);
22821 }
22822 }
22823 if (_v) {
22824 return _wrap_DateTime___isub____SWIG_1(self,args);
22825 }
22826 }
22827 }
22828
22829 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22830 return NULL;
22831 }
22832
22833
22834 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22835 PyObject *resultobj;
22836 wxDateTime *arg1 = (wxDateTime *) 0 ;
22837 wxTimeSpan *arg2 = 0 ;
22838 wxDateTime result;
22839 PyObject * obj0 = 0 ;
22840 PyObject * obj1 = 0 ;
22841
22842 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22844 if (SWIG_arg_fail(1)) SWIG_fail;
22845 {
22846 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22847 if (SWIG_arg_fail(2)) SWIG_fail;
22848 if (arg2 == NULL) {
22849 SWIG_null_ref("wxTimeSpan");
22850 }
22851 if (SWIG_arg_fail(2)) SWIG_fail;
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22856
22857 wxPyEndAllowThreads(__tstate);
22858 if (PyErr_Occurred()) SWIG_fail;
22859 }
22860 {
22861 wxDateTime * resultptr;
22862 resultptr = new wxDateTime((wxDateTime &)(result));
22863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22872 PyObject *resultobj;
22873 wxDateTime *arg1 = (wxDateTime *) 0 ;
22874 wxDateSpan *arg2 = 0 ;
22875 wxDateTime result;
22876 PyObject * obj0 = 0 ;
22877 PyObject * obj1 = 0 ;
22878
22879 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22881 if (SWIG_arg_fail(1)) SWIG_fail;
22882 {
22883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22884 if (SWIG_arg_fail(2)) SWIG_fail;
22885 if (arg2 == NULL) {
22886 SWIG_null_ref("wxDateSpan");
22887 }
22888 if (SWIG_arg_fail(2)) SWIG_fail;
22889 }
22890 {
22891 PyThreadState* __tstate = wxPyBeginAllowThreads();
22892 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22893
22894 wxPyEndAllowThreads(__tstate);
22895 if (PyErr_Occurred()) SWIG_fail;
22896 }
22897 {
22898 wxDateTime * resultptr;
22899 resultptr = new wxDateTime((wxDateTime &)(result));
22900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22901 }
22902 return resultobj;
22903 fail:
22904 return NULL;
22905 }
22906
22907
22908 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22909 int argc;
22910 PyObject *argv[3];
22911 int ii;
22912
22913 argc = PyObject_Length(args);
22914 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22915 argv[ii] = PyTuple_GetItem(args,ii);
22916 }
22917 if (argc == 2) {
22918 int _v;
22919 {
22920 void *ptr;
22921 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22922 _v = 0;
22923 PyErr_Clear();
22924 } else {
22925 _v = 1;
22926 }
22927 }
22928 if (_v) {
22929 {
22930 void *ptr = 0;
22931 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22932 _v = 0;
22933 PyErr_Clear();
22934 } else {
22935 _v = (ptr != 0);
22936 }
22937 }
22938 if (_v) {
22939 return _wrap_DateTime___add____SWIG_0(self,args);
22940 }
22941 }
22942 }
22943 if (argc == 2) {
22944 int _v;
22945 {
22946 void *ptr;
22947 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22948 _v = 0;
22949 PyErr_Clear();
22950 } else {
22951 _v = 1;
22952 }
22953 }
22954 if (_v) {
22955 {
22956 void *ptr = 0;
22957 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22958 _v = 0;
22959 PyErr_Clear();
22960 } else {
22961 _v = (ptr != 0);
22962 }
22963 }
22964 if (_v) {
22965 return _wrap_DateTime___add____SWIG_1(self,args);
22966 }
22967 }
22968 }
22969
22970 Py_INCREF(Py_NotImplemented);
22971 return Py_NotImplemented;
22972 }
22973
22974
22975 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22976 PyObject *resultobj;
22977 wxDateTime *arg1 = (wxDateTime *) 0 ;
22978 wxDateTime *arg2 = 0 ;
22979 wxTimeSpan result;
22980 PyObject * obj0 = 0 ;
22981 PyObject * obj1 = 0 ;
22982
22983 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22985 if (SWIG_arg_fail(1)) SWIG_fail;
22986 {
22987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22988 if (SWIG_arg_fail(2)) SWIG_fail;
22989 if (arg2 == NULL) {
22990 SWIG_null_ref("wxDateTime");
22991 }
22992 if (SWIG_arg_fail(2)) SWIG_fail;
22993 }
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22997
22998 wxPyEndAllowThreads(__tstate);
22999 if (PyErr_Occurred()) SWIG_fail;
23000 }
23001 {
23002 wxTimeSpan * resultptr;
23003 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23004 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23005 }
23006 return resultobj;
23007 fail:
23008 return NULL;
23009 }
23010
23011
23012 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
23013 PyObject *resultobj;
23014 wxDateTime *arg1 = (wxDateTime *) 0 ;
23015 wxTimeSpan *arg2 = 0 ;
23016 wxDateTime result;
23017 PyObject * obj0 = 0 ;
23018 PyObject * obj1 = 0 ;
23019
23020 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23022 if (SWIG_arg_fail(1)) SWIG_fail;
23023 {
23024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
23025 if (SWIG_arg_fail(2)) SWIG_fail;
23026 if (arg2 == NULL) {
23027 SWIG_null_ref("wxTimeSpan");
23028 }
23029 if (SWIG_arg_fail(2)) SWIG_fail;
23030 }
23031 {
23032 PyThreadState* __tstate = wxPyBeginAllowThreads();
23033 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
23034
23035 wxPyEndAllowThreads(__tstate);
23036 if (PyErr_Occurred()) SWIG_fail;
23037 }
23038 {
23039 wxDateTime * resultptr;
23040 resultptr = new wxDateTime((wxDateTime &)(result));
23041 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
23050 PyObject *resultobj;
23051 wxDateTime *arg1 = (wxDateTime *) 0 ;
23052 wxDateSpan *arg2 = 0 ;
23053 wxDateTime result;
23054 PyObject * obj0 = 0 ;
23055 PyObject * obj1 = 0 ;
23056
23057 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23059 if (SWIG_arg_fail(1)) SWIG_fail;
23060 {
23061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23062 if (SWIG_arg_fail(2)) SWIG_fail;
23063 if (arg2 == NULL) {
23064 SWIG_null_ref("wxDateSpan");
23065 }
23066 if (SWIG_arg_fail(2)) SWIG_fail;
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23071
23072 wxPyEndAllowThreads(__tstate);
23073 if (PyErr_Occurred()) SWIG_fail;
23074 }
23075 {
23076 wxDateTime * resultptr;
23077 resultptr = new wxDateTime((wxDateTime &)(result));
23078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23079 }
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23087 int argc;
23088 PyObject *argv[3];
23089 int ii;
23090
23091 argc = PyObject_Length(args);
23092 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23093 argv[ii] = PyTuple_GetItem(args,ii);
23094 }
23095 if (argc == 2) {
23096 int _v;
23097 {
23098 void *ptr;
23099 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23100 _v = 0;
23101 PyErr_Clear();
23102 } else {
23103 _v = 1;
23104 }
23105 }
23106 if (_v) {
23107 {
23108 void *ptr = 0;
23109 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23110 _v = 0;
23111 PyErr_Clear();
23112 } else {
23113 _v = (ptr != 0);
23114 }
23115 }
23116 if (_v) {
23117 return _wrap_DateTime___sub____SWIG_0(self,args);
23118 }
23119 }
23120 }
23121 if (argc == 2) {
23122 int _v;
23123 {
23124 void *ptr;
23125 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23126 _v = 0;
23127 PyErr_Clear();
23128 } else {
23129 _v = 1;
23130 }
23131 }
23132 if (_v) {
23133 {
23134 void *ptr = 0;
23135 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23136 _v = 0;
23137 PyErr_Clear();
23138 } else {
23139 _v = (ptr != 0);
23140 }
23141 }
23142 if (_v) {
23143 return _wrap_DateTime___sub____SWIG_1(self,args);
23144 }
23145 }
23146 }
23147 if (argc == 2) {
23148 int _v;
23149 {
23150 void *ptr;
23151 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23152 _v = 0;
23153 PyErr_Clear();
23154 } else {
23155 _v = 1;
23156 }
23157 }
23158 if (_v) {
23159 {
23160 void *ptr = 0;
23161 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23162 _v = 0;
23163 PyErr_Clear();
23164 } else {
23165 _v = (ptr != 0);
23166 }
23167 }
23168 if (_v) {
23169 return _wrap_DateTime___sub____SWIG_2(self,args);
23170 }
23171 }
23172 }
23173
23174 Py_INCREF(Py_NotImplemented);
23175 return Py_NotImplemented;
23176 }
23177
23178
23179 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23180 PyObject *resultobj;
23181 wxDateTime *arg1 = (wxDateTime *) 0 ;
23182 wxDateTime *arg2 = (wxDateTime *) 0 ;
23183 bool result;
23184 PyObject * obj0 = 0 ;
23185 PyObject * obj1 = 0 ;
23186 char *kwnames[] = {
23187 (char *) "self",(char *) "other", NULL
23188 };
23189
23190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23192 if (SWIG_arg_fail(1)) SWIG_fail;
23193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23194 if (SWIG_arg_fail(2)) SWIG_fail;
23195 {
23196 PyThreadState* __tstate = wxPyBeginAllowThreads();
23197 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23198
23199 wxPyEndAllowThreads(__tstate);
23200 if (PyErr_Occurred()) SWIG_fail;
23201 }
23202 {
23203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23204 }
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23212 PyObject *resultobj;
23213 wxDateTime *arg1 = (wxDateTime *) 0 ;
23214 wxDateTime *arg2 = (wxDateTime *) 0 ;
23215 bool result;
23216 PyObject * obj0 = 0 ;
23217 PyObject * obj1 = 0 ;
23218 char *kwnames[] = {
23219 (char *) "self",(char *) "other", NULL
23220 };
23221
23222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23224 if (SWIG_arg_fail(1)) SWIG_fail;
23225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23226 if (SWIG_arg_fail(2)) SWIG_fail;
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23230
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 {
23235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23236 }
23237 return resultobj;
23238 fail:
23239 return NULL;
23240 }
23241
23242
23243 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23244 PyObject *resultobj;
23245 wxDateTime *arg1 = (wxDateTime *) 0 ;
23246 wxDateTime *arg2 = (wxDateTime *) 0 ;
23247 bool result;
23248 PyObject * obj0 = 0 ;
23249 PyObject * obj1 = 0 ;
23250 char *kwnames[] = {
23251 (char *) "self",(char *) "other", NULL
23252 };
23253
23254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(1)) SWIG_fail;
23257 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23258 if (SWIG_arg_fail(2)) SWIG_fail;
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23262
23263 wxPyEndAllowThreads(__tstate);
23264 if (PyErr_Occurred()) SWIG_fail;
23265 }
23266 {
23267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23268 }
23269 return resultobj;
23270 fail:
23271 return NULL;
23272 }
23273
23274
23275 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23276 PyObject *resultobj;
23277 wxDateTime *arg1 = (wxDateTime *) 0 ;
23278 wxDateTime *arg2 = (wxDateTime *) 0 ;
23279 bool result;
23280 PyObject * obj0 = 0 ;
23281 PyObject * obj1 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "self",(char *) "other", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(1)) SWIG_fail;
23289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23290 if (SWIG_arg_fail(2)) SWIG_fail;
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23308 PyObject *resultobj;
23309 wxDateTime *arg1 = (wxDateTime *) 0 ;
23310 wxDateTime *arg2 = (wxDateTime *) 0 ;
23311 bool result;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23314 char *kwnames[] = {
23315 (char *) "self",(char *) "other", NULL
23316 };
23317
23318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23320 if (SWIG_arg_fail(1)) SWIG_fail;
23321 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23322 if (SWIG_arg_fail(2)) SWIG_fail;
23323 {
23324 PyThreadState* __tstate = wxPyBeginAllowThreads();
23325 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23326
23327 wxPyEndAllowThreads(__tstate);
23328 if (PyErr_Occurred()) SWIG_fail;
23329 }
23330 {
23331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23332 }
23333 return resultobj;
23334 fail:
23335 return NULL;
23336 }
23337
23338
23339 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23340 PyObject *resultobj;
23341 wxDateTime *arg1 = (wxDateTime *) 0 ;
23342 wxDateTime *arg2 = (wxDateTime *) 0 ;
23343 bool result;
23344 PyObject * obj0 = 0 ;
23345 PyObject * obj1 = 0 ;
23346 char *kwnames[] = {
23347 (char *) "self",(char *) "other", NULL
23348 };
23349
23350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23352 if (SWIG_arg_fail(1)) SWIG_fail;
23353 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23354 if (SWIG_arg_fail(2)) SWIG_fail;
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23358
23359 wxPyEndAllowThreads(__tstate);
23360 if (PyErr_Occurred()) SWIG_fail;
23361 }
23362 {
23363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23364 }
23365 return resultobj;
23366 fail:
23367 return NULL;
23368 }
23369
23370
23371 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23372 PyObject *resultobj;
23373 wxDateTime *arg1 = (wxDateTime *) 0 ;
23374 wxString *arg2 = 0 ;
23375 int result;
23376 bool temp2 = false ;
23377 PyObject * obj0 = 0 ;
23378 PyObject * obj1 = 0 ;
23379 char *kwnames[] = {
23380 (char *) "self",(char *) "date", NULL
23381 };
23382
23383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23385 if (SWIG_arg_fail(1)) SWIG_fail;
23386 {
23387 arg2 = wxString_in_helper(obj1);
23388 if (arg2 == NULL) SWIG_fail;
23389 temp2 = true;
23390 }
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23394
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 {
23399 resultobj = SWIG_From_int((int)(result));
23400 }
23401 {
23402 if (temp2)
23403 delete arg2;
23404 }
23405 return resultobj;
23406 fail:
23407 {
23408 if (temp2)
23409 delete arg2;
23410 }
23411 return NULL;
23412 }
23413
23414
23415 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23416 PyObject *resultobj;
23417 wxDateTime *arg1 = (wxDateTime *) 0 ;
23418 wxString *arg2 = 0 ;
23419 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23420 wxString *arg3 = (wxString *) &arg3_defvalue ;
23421 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23422 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23423 int result;
23424 bool temp2 = false ;
23425 bool temp3 = false ;
23426 PyObject * obj0 = 0 ;
23427 PyObject * obj1 = 0 ;
23428 PyObject * obj2 = 0 ;
23429 PyObject * obj3 = 0 ;
23430 char *kwnames[] = {
23431 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23432 };
23433
23434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23436 if (SWIG_arg_fail(1)) SWIG_fail;
23437 {
23438 arg2 = wxString_in_helper(obj1);
23439 if (arg2 == NULL) SWIG_fail;
23440 temp2 = true;
23441 }
23442 if (obj2) {
23443 {
23444 arg3 = wxString_in_helper(obj2);
23445 if (arg3 == NULL) SWIG_fail;
23446 temp3 = true;
23447 }
23448 }
23449 if (obj3) {
23450 {
23451 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23452 if (SWIG_arg_fail(4)) SWIG_fail;
23453 if (arg4 == NULL) {
23454 SWIG_null_ref("wxDateTime");
23455 }
23456 if (SWIG_arg_fail(4)) SWIG_fail;
23457 }
23458 }
23459 {
23460 PyThreadState* __tstate = wxPyBeginAllowThreads();
23461 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23462
23463 wxPyEndAllowThreads(__tstate);
23464 if (PyErr_Occurred()) SWIG_fail;
23465 }
23466 {
23467 resultobj = SWIG_From_int((int)(result));
23468 }
23469 {
23470 if (temp2)
23471 delete arg2;
23472 }
23473 {
23474 if (temp3)
23475 delete arg3;
23476 }
23477 return resultobj;
23478 fail:
23479 {
23480 if (temp2)
23481 delete arg2;
23482 }
23483 {
23484 if (temp3)
23485 delete arg3;
23486 }
23487 return NULL;
23488 }
23489
23490
23491 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23492 PyObject *resultobj;
23493 wxDateTime *arg1 = (wxDateTime *) 0 ;
23494 wxString *arg2 = 0 ;
23495 int result;
23496 bool temp2 = false ;
23497 PyObject * obj0 = 0 ;
23498 PyObject * obj1 = 0 ;
23499 char *kwnames[] = {
23500 (char *) "self",(char *) "datetime", NULL
23501 };
23502
23503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23505 if (SWIG_arg_fail(1)) SWIG_fail;
23506 {
23507 arg2 = wxString_in_helper(obj1);
23508 if (arg2 == NULL) SWIG_fail;
23509 temp2 = true;
23510 }
23511 {
23512 PyThreadState* __tstate = wxPyBeginAllowThreads();
23513 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23514
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = SWIG_From_int((int)(result));
23520 }
23521 {
23522 if (temp2)
23523 delete arg2;
23524 }
23525 return resultobj;
23526 fail:
23527 {
23528 if (temp2)
23529 delete arg2;
23530 }
23531 return NULL;
23532 }
23533
23534
23535 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj;
23537 wxDateTime *arg1 = (wxDateTime *) 0 ;
23538 wxString *arg2 = 0 ;
23539 int result;
23540 bool temp2 = false ;
23541 PyObject * obj0 = 0 ;
23542 PyObject * obj1 = 0 ;
23543 char *kwnames[] = {
23544 (char *) "self",(char *) "date", NULL
23545 };
23546
23547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23549 if (SWIG_arg_fail(1)) SWIG_fail;
23550 {
23551 arg2 = wxString_in_helper(obj1);
23552 if (arg2 == NULL) SWIG_fail;
23553 temp2 = true;
23554 }
23555 {
23556 PyThreadState* __tstate = wxPyBeginAllowThreads();
23557 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23558
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 {
23563 resultobj = SWIG_From_int((int)(result));
23564 }
23565 {
23566 if (temp2)
23567 delete arg2;
23568 }
23569 return resultobj;
23570 fail:
23571 {
23572 if (temp2)
23573 delete arg2;
23574 }
23575 return NULL;
23576 }
23577
23578
23579 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23580 PyObject *resultobj;
23581 wxDateTime *arg1 = (wxDateTime *) 0 ;
23582 wxString *arg2 = 0 ;
23583 int result;
23584 bool temp2 = false ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char *kwnames[] = {
23588 (char *) "self",(char *) "time", NULL
23589 };
23590
23591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23593 if (SWIG_arg_fail(1)) SWIG_fail;
23594 {
23595 arg2 = wxString_in_helper(obj1);
23596 if (arg2 == NULL) SWIG_fail;
23597 temp2 = true;
23598 }
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 {
23607 resultobj = SWIG_From_int((int)(result));
23608 }
23609 {
23610 if (temp2)
23611 delete arg2;
23612 }
23613 return resultobj;
23614 fail:
23615 {
23616 if (temp2)
23617 delete arg2;
23618 }
23619 return NULL;
23620 }
23621
23622
23623 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23624 PyObject *resultobj;
23625 wxDateTime *arg1 = (wxDateTime *) 0 ;
23626 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23627 wxString *arg2 = (wxString *) &arg2_defvalue ;
23628 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23629 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23630 wxString result;
23631 bool temp2 = false ;
23632 bool temp3 = false ;
23633 PyObject * obj0 = 0 ;
23634 PyObject * obj1 = 0 ;
23635 PyObject * obj2 = 0 ;
23636 char *kwnames[] = {
23637 (char *) "self",(char *) "format",(char *) "tz", NULL
23638 };
23639
23640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23642 if (SWIG_arg_fail(1)) SWIG_fail;
23643 if (obj1) {
23644 {
23645 arg2 = wxString_in_helper(obj1);
23646 if (arg2 == NULL) SWIG_fail;
23647 temp2 = true;
23648 }
23649 }
23650 if (obj2) {
23651 {
23652 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23653 temp3 = true;
23654 }
23655 }
23656 {
23657 PyThreadState* __tstate = wxPyBeginAllowThreads();
23658 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23659
23660 wxPyEndAllowThreads(__tstate);
23661 if (PyErr_Occurred()) SWIG_fail;
23662 }
23663 {
23664 #if wxUSE_UNICODE
23665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23666 #else
23667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23668 #endif
23669 }
23670 {
23671 if (temp2)
23672 delete arg2;
23673 }
23674 {
23675 if (temp3) delete arg3;
23676 }
23677 return resultobj;
23678 fail:
23679 {
23680 if (temp2)
23681 delete arg2;
23682 }
23683 {
23684 if (temp3) delete arg3;
23685 }
23686 return NULL;
23687 }
23688
23689
23690 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23691 PyObject *resultobj;
23692 wxDateTime *arg1 = (wxDateTime *) 0 ;
23693 wxString result;
23694 PyObject * obj0 = 0 ;
23695 char *kwnames[] = {
23696 (char *) "self", NULL
23697 };
23698
23699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23701 if (SWIG_arg_fail(1)) SWIG_fail;
23702 {
23703 PyThreadState* __tstate = wxPyBeginAllowThreads();
23704 result = ((wxDateTime const *)arg1)->FormatDate();
23705
23706 wxPyEndAllowThreads(__tstate);
23707 if (PyErr_Occurred()) SWIG_fail;
23708 }
23709 {
23710 #if wxUSE_UNICODE
23711 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23712 #else
23713 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23714 #endif
23715 }
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23723 PyObject *resultobj;
23724 wxDateTime *arg1 = (wxDateTime *) 0 ;
23725 wxString result;
23726 PyObject * obj0 = 0 ;
23727 char *kwnames[] = {
23728 (char *) "self", NULL
23729 };
23730
23731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23733 if (SWIG_arg_fail(1)) SWIG_fail;
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 result = ((wxDateTime const *)arg1)->FormatTime();
23737
23738 wxPyEndAllowThreads(__tstate);
23739 if (PyErr_Occurred()) SWIG_fail;
23740 }
23741 {
23742 #if wxUSE_UNICODE
23743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23744 #else
23745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23746 #endif
23747 }
23748 return resultobj;
23749 fail:
23750 return NULL;
23751 }
23752
23753
23754 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23755 PyObject *resultobj;
23756 wxDateTime *arg1 = (wxDateTime *) 0 ;
23757 wxString result;
23758 PyObject * obj0 = 0 ;
23759 char *kwnames[] = {
23760 (char *) "self", NULL
23761 };
23762
23763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23765 if (SWIG_arg_fail(1)) SWIG_fail;
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = ((wxDateTime const *)arg1)->FormatISODate();
23769
23770 wxPyEndAllowThreads(__tstate);
23771 if (PyErr_Occurred()) SWIG_fail;
23772 }
23773 {
23774 #if wxUSE_UNICODE
23775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23776 #else
23777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23778 #endif
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 wxDateTime *arg1 = (wxDateTime *) 0 ;
23789 wxString result;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "self", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23797 if (SWIG_arg_fail(1)) SWIG_fail;
23798 {
23799 PyThreadState* __tstate = wxPyBeginAllowThreads();
23800 result = ((wxDateTime const *)arg1)->FormatISOTime();
23801
23802 wxPyEndAllowThreads(__tstate);
23803 if (PyErr_Occurred()) SWIG_fail;
23804 }
23805 {
23806 #if wxUSE_UNICODE
23807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23808 #else
23809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23810 #endif
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23819 PyObject *obj;
23820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23821 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23822 Py_INCREF(obj);
23823 return Py_BuildValue((char *)"");
23824 }
23825 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23826 PyObject *resultobj;
23827 long arg1 ;
23828 wxTimeSpan result;
23829 PyObject * obj0 = 0 ;
23830 char *kwnames[] = {
23831 (char *) "sec", NULL
23832 };
23833
23834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23835 {
23836 arg1 = (long)(SWIG_As_long(obj0));
23837 if (SWIG_arg_fail(1)) SWIG_fail;
23838 }
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = wxTimeSpan::Seconds(arg1);
23842
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 wxTimeSpan * resultptr;
23848 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23849 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23850 }
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj;
23859 wxTimeSpan result;
23860 char *kwnames[] = {
23861 NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = wxTimeSpan::Second();
23868
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 wxTimeSpan * resultptr;
23874 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23876 }
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23884 PyObject *resultobj;
23885 long arg1 ;
23886 wxTimeSpan result;
23887 PyObject * obj0 = 0 ;
23888 char *kwnames[] = {
23889 (char *) "min", NULL
23890 };
23891
23892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23893 {
23894 arg1 = (long)(SWIG_As_long(obj0));
23895 if (SWIG_arg_fail(1)) SWIG_fail;
23896 }
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = wxTimeSpan::Minutes(arg1);
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 {
23905 wxTimeSpan * resultptr;
23906 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23916 PyObject *resultobj;
23917 wxTimeSpan result;
23918 char *kwnames[] = {
23919 NULL
23920 };
23921
23922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = wxTimeSpan::Minute();
23926
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 {
23931 wxTimeSpan * resultptr;
23932 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23933 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23934 }
23935 return resultobj;
23936 fail:
23937 return NULL;
23938 }
23939
23940
23941 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23942 PyObject *resultobj;
23943 long arg1 ;
23944 wxTimeSpan result;
23945 PyObject * obj0 = 0 ;
23946 char *kwnames[] = {
23947 (char *) "hours", NULL
23948 };
23949
23950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23951 {
23952 arg1 = (long)(SWIG_As_long(obj0));
23953 if (SWIG_arg_fail(1)) SWIG_fail;
23954 }
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = wxTimeSpan::Hours(arg1);
23958
23959 wxPyEndAllowThreads(__tstate);
23960 if (PyErr_Occurred()) SWIG_fail;
23961 }
23962 {
23963 wxTimeSpan * resultptr;
23964 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23965 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23966 }
23967 return resultobj;
23968 fail:
23969 return NULL;
23970 }
23971
23972
23973 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23974 PyObject *resultobj;
23975 wxTimeSpan result;
23976 char *kwnames[] = {
23977 NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = wxTimeSpan::Hour();
23984
23985 wxPyEndAllowThreads(__tstate);
23986 if (PyErr_Occurred()) SWIG_fail;
23987 }
23988 {
23989 wxTimeSpan * resultptr;
23990 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23991 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23992 }
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 long arg1 ;
24002 wxTimeSpan result;
24003 PyObject * obj0 = 0 ;
24004 char *kwnames[] = {
24005 (char *) "days", NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
24009 {
24010 arg1 = (long)(SWIG_As_long(obj0));
24011 if (SWIG_arg_fail(1)) SWIG_fail;
24012 }
24013 {
24014 PyThreadState* __tstate = wxPyBeginAllowThreads();
24015 result = wxTimeSpan::Days(arg1);
24016
24017 wxPyEndAllowThreads(__tstate);
24018 if (PyErr_Occurred()) SWIG_fail;
24019 }
24020 {
24021 wxTimeSpan * resultptr;
24022 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24023 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24024 }
24025 return resultobj;
24026 fail:
24027 return NULL;
24028 }
24029
24030
24031 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
24032 PyObject *resultobj;
24033 wxTimeSpan result;
24034 char *kwnames[] = {
24035 NULL
24036 };
24037
24038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = wxTimeSpan::Day();
24042
24043 wxPyEndAllowThreads(__tstate);
24044 if (PyErr_Occurred()) SWIG_fail;
24045 }
24046 {
24047 wxTimeSpan * resultptr;
24048 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24050 }
24051 return resultobj;
24052 fail:
24053 return NULL;
24054 }
24055
24056
24057 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj;
24059 long arg1 ;
24060 wxTimeSpan result;
24061 PyObject * obj0 = 0 ;
24062 char *kwnames[] = {
24063 (char *) "days", NULL
24064 };
24065
24066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24067 {
24068 arg1 = (long)(SWIG_As_long(obj0));
24069 if (SWIG_arg_fail(1)) SWIG_fail;
24070 }
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = wxTimeSpan::Weeks(arg1);
24074
24075 wxPyEndAllowThreads(__tstate);
24076 if (PyErr_Occurred()) SWIG_fail;
24077 }
24078 {
24079 wxTimeSpan * resultptr;
24080 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24081 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24082 }
24083 return resultobj;
24084 fail:
24085 return NULL;
24086 }
24087
24088
24089 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24090 PyObject *resultobj;
24091 wxTimeSpan result;
24092 char *kwnames[] = {
24093 NULL
24094 };
24095
24096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24097 {
24098 PyThreadState* __tstate = wxPyBeginAllowThreads();
24099 result = wxTimeSpan::Week();
24100
24101 wxPyEndAllowThreads(__tstate);
24102 if (PyErr_Occurred()) SWIG_fail;
24103 }
24104 {
24105 wxTimeSpan * resultptr;
24106 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24107 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24108 }
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24116 PyObject *resultobj;
24117 long arg1 = (long) 0 ;
24118 long arg2 = (long) 0 ;
24119 long arg3 = (long) 0 ;
24120 long arg4 = (long) 0 ;
24121 wxTimeSpan *result;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 PyObject * obj2 = 0 ;
24125 PyObject * obj3 = 0 ;
24126 char *kwnames[] = {
24127 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24128 };
24129
24130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24131 if (obj0) {
24132 {
24133 arg1 = (long)(SWIG_As_long(obj0));
24134 if (SWIG_arg_fail(1)) SWIG_fail;
24135 }
24136 }
24137 if (obj1) {
24138 {
24139 arg2 = (long)(SWIG_As_long(obj1));
24140 if (SWIG_arg_fail(2)) SWIG_fail;
24141 }
24142 }
24143 if (obj2) {
24144 {
24145 arg3 = (long)(SWIG_As_long(obj2));
24146 if (SWIG_arg_fail(3)) SWIG_fail;
24147 }
24148 }
24149 if (obj3) {
24150 {
24151 arg4 = (long)(SWIG_As_long(obj3));
24152 if (SWIG_arg_fail(4)) SWIG_fail;
24153 }
24154 }
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24158
24159 wxPyEndAllowThreads(__tstate);
24160 if (PyErr_Occurred()) SWIG_fail;
24161 }
24162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24163 return resultobj;
24164 fail:
24165 return NULL;
24166 }
24167
24168
24169 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24170 PyObject *resultobj;
24171 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24172 PyObject * obj0 = 0 ;
24173 char *kwnames[] = {
24174 (char *) "self", NULL
24175 };
24176
24177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24179 if (SWIG_arg_fail(1)) SWIG_fail;
24180 {
24181 PyThreadState* __tstate = wxPyBeginAllowThreads();
24182 delete arg1;
24183
24184 wxPyEndAllowThreads(__tstate);
24185 if (PyErr_Occurred()) SWIG_fail;
24186 }
24187 Py_INCREF(Py_None); resultobj = Py_None;
24188 return resultobj;
24189 fail:
24190 return NULL;
24191 }
24192
24193
24194 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24195 PyObject *resultobj;
24196 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24197 wxTimeSpan *arg2 = 0 ;
24198 wxTimeSpan *result;
24199 PyObject * obj0 = 0 ;
24200 PyObject * obj1 = 0 ;
24201 char *kwnames[] = {
24202 (char *) "self",(char *) "diff", NULL
24203 };
24204
24205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24207 if (SWIG_arg_fail(1)) SWIG_fail;
24208 {
24209 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24210 if (SWIG_arg_fail(2)) SWIG_fail;
24211 if (arg2 == NULL) {
24212 SWIG_null_ref("wxTimeSpan");
24213 }
24214 if (SWIG_arg_fail(2)) SWIG_fail;
24215 }
24216 {
24217 PyThreadState* __tstate = wxPyBeginAllowThreads();
24218 {
24219 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24220 result = (wxTimeSpan *) &_result_ref;
24221 }
24222
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24227 return resultobj;
24228 fail:
24229 return NULL;
24230 }
24231
24232
24233 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24234 PyObject *resultobj;
24235 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24236 wxTimeSpan *arg2 = 0 ;
24237 wxTimeSpan *result;
24238 PyObject * obj0 = 0 ;
24239 PyObject * obj1 = 0 ;
24240 char *kwnames[] = {
24241 (char *) "self",(char *) "diff", NULL
24242 };
24243
24244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24246 if (SWIG_arg_fail(1)) SWIG_fail;
24247 {
24248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24249 if (SWIG_arg_fail(2)) SWIG_fail;
24250 if (arg2 == NULL) {
24251 SWIG_null_ref("wxTimeSpan");
24252 }
24253 if (SWIG_arg_fail(2)) SWIG_fail;
24254 }
24255 {
24256 PyThreadState* __tstate = wxPyBeginAllowThreads();
24257 {
24258 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24259 result = (wxTimeSpan *) &_result_ref;
24260 }
24261
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24266 return resultobj;
24267 fail:
24268 return NULL;
24269 }
24270
24271
24272 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24273 PyObject *resultobj;
24274 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24275 int arg2 ;
24276 wxTimeSpan *result;
24277 PyObject * obj0 = 0 ;
24278 PyObject * obj1 = 0 ;
24279 char *kwnames[] = {
24280 (char *) "self",(char *) "n", NULL
24281 };
24282
24283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24285 if (SWIG_arg_fail(1)) SWIG_fail;
24286 {
24287 arg2 = (int)(SWIG_As_int(obj1));
24288 if (SWIG_arg_fail(2)) SWIG_fail;
24289 }
24290 {
24291 PyThreadState* __tstate = wxPyBeginAllowThreads();
24292 {
24293 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24294 result = (wxTimeSpan *) &_result_ref;
24295 }
24296
24297 wxPyEndAllowThreads(__tstate);
24298 if (PyErr_Occurred()) SWIG_fail;
24299 }
24300 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24301 return resultobj;
24302 fail:
24303 return NULL;
24304 }
24305
24306
24307 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24308 PyObject *resultobj;
24309 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24310 wxTimeSpan *result;
24311 PyObject * obj0 = 0 ;
24312 char *kwnames[] = {
24313 (char *) "self", NULL
24314 };
24315
24316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24318 if (SWIG_arg_fail(1)) SWIG_fail;
24319 {
24320 PyThreadState* __tstate = wxPyBeginAllowThreads();
24321 {
24322 wxTimeSpan &_result_ref = (arg1)->Neg();
24323 result = (wxTimeSpan *) &_result_ref;
24324 }
24325
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj;
24338 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24339 wxTimeSpan result;
24340 PyObject * obj0 = 0 ;
24341 char *kwnames[] = {
24342 (char *) "self", NULL
24343 };
24344
24345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24347 if (SWIG_arg_fail(1)) SWIG_fail;
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 result = ((wxTimeSpan const *)arg1)->Abs();
24351
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 {
24356 wxTimeSpan * resultptr;
24357 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24359 }
24360 return resultobj;
24361 fail:
24362 return NULL;
24363 }
24364
24365
24366 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24367 PyObject *resultobj;
24368 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24369 wxTimeSpan *arg2 = 0 ;
24370 wxTimeSpan *result;
24371 PyObject * obj0 = 0 ;
24372 PyObject * obj1 = 0 ;
24373 char *kwnames[] = {
24374 (char *) "self",(char *) "diff", NULL
24375 };
24376
24377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24379 if (SWIG_arg_fail(1)) SWIG_fail;
24380 {
24381 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24382 if (SWIG_arg_fail(2)) SWIG_fail;
24383 if (arg2 == NULL) {
24384 SWIG_null_ref("wxTimeSpan");
24385 }
24386 if (SWIG_arg_fail(2)) SWIG_fail;
24387 }
24388 {
24389 PyThreadState* __tstate = wxPyBeginAllowThreads();
24390 {
24391 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24392 result = (wxTimeSpan *) &_result_ref;
24393 }
24394
24395 wxPyEndAllowThreads(__tstate);
24396 if (PyErr_Occurred()) SWIG_fail;
24397 }
24398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24399 return resultobj;
24400 fail:
24401 return NULL;
24402 }
24403
24404
24405 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24406 PyObject *resultobj;
24407 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24408 wxTimeSpan *arg2 = 0 ;
24409 wxTimeSpan *result;
24410 PyObject * obj0 = 0 ;
24411 PyObject * obj1 = 0 ;
24412 char *kwnames[] = {
24413 (char *) "self",(char *) "diff", NULL
24414 };
24415
24416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24418 if (SWIG_arg_fail(1)) SWIG_fail;
24419 {
24420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24421 if (SWIG_arg_fail(2)) SWIG_fail;
24422 if (arg2 == NULL) {
24423 SWIG_null_ref("wxTimeSpan");
24424 }
24425 if (SWIG_arg_fail(2)) SWIG_fail;
24426 }
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 {
24430 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24431 result = (wxTimeSpan *) &_result_ref;
24432 }
24433
24434 wxPyEndAllowThreads(__tstate);
24435 if (PyErr_Occurred()) SWIG_fail;
24436 }
24437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24438 return resultobj;
24439 fail:
24440 return NULL;
24441 }
24442
24443
24444 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24445 PyObject *resultobj;
24446 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24447 int arg2 ;
24448 wxTimeSpan *result;
24449 PyObject * obj0 = 0 ;
24450 PyObject * obj1 = 0 ;
24451 char *kwnames[] = {
24452 (char *) "self",(char *) "n", NULL
24453 };
24454
24455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24457 if (SWIG_arg_fail(1)) SWIG_fail;
24458 {
24459 arg2 = (int)(SWIG_As_int(obj1));
24460 if (SWIG_arg_fail(2)) SWIG_fail;
24461 }
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 {
24465 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24466 result = (wxTimeSpan *) &_result_ref;
24467 }
24468
24469 wxPyEndAllowThreads(__tstate);
24470 if (PyErr_Occurred()) SWIG_fail;
24471 }
24472 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24473 return resultobj;
24474 fail:
24475 return NULL;
24476 }
24477
24478
24479 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24480 PyObject *resultobj;
24481 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24482 wxTimeSpan *result;
24483 PyObject * obj0 = 0 ;
24484 char *kwnames[] = {
24485 (char *) "self", NULL
24486 };
24487
24488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24490 if (SWIG_arg_fail(1)) SWIG_fail;
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 {
24494 wxTimeSpan &_result_ref = (arg1)->operator -();
24495 result = (wxTimeSpan *) &_result_ref;
24496 }
24497
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj;
24510 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24511 wxTimeSpan *arg2 = 0 ;
24512 wxTimeSpan result;
24513 PyObject * obj0 = 0 ;
24514 PyObject * obj1 = 0 ;
24515 char *kwnames[] = {
24516 (char *) "self",(char *) "other", NULL
24517 };
24518
24519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24521 if (SWIG_arg_fail(1)) SWIG_fail;
24522 {
24523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24524 if (SWIG_arg_fail(2)) SWIG_fail;
24525 if (arg2 == NULL) {
24526 SWIG_null_ref("wxTimeSpan");
24527 }
24528 if (SWIG_arg_fail(2)) SWIG_fail;
24529 }
24530 {
24531 PyThreadState* __tstate = wxPyBeginAllowThreads();
24532 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24533
24534 wxPyEndAllowThreads(__tstate);
24535 if (PyErr_Occurred()) SWIG_fail;
24536 }
24537 {
24538 wxTimeSpan * resultptr;
24539 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24541 }
24542 return resultobj;
24543 fail:
24544 return NULL;
24545 }
24546
24547
24548 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24549 PyObject *resultobj;
24550 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24551 wxTimeSpan *arg2 = 0 ;
24552 wxTimeSpan result;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 char *kwnames[] = {
24556 (char *) "self",(char *) "other", NULL
24557 };
24558
24559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24561 if (SWIG_arg_fail(1)) SWIG_fail;
24562 {
24563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24564 if (SWIG_arg_fail(2)) SWIG_fail;
24565 if (arg2 == NULL) {
24566 SWIG_null_ref("wxTimeSpan");
24567 }
24568 if (SWIG_arg_fail(2)) SWIG_fail;
24569 }
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24573
24574 wxPyEndAllowThreads(__tstate);
24575 if (PyErr_Occurred()) SWIG_fail;
24576 }
24577 {
24578 wxTimeSpan * resultptr;
24579 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24581 }
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24589 PyObject *resultobj;
24590 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24591 int arg2 ;
24592 wxTimeSpan result;
24593 PyObject * obj0 = 0 ;
24594 PyObject * obj1 = 0 ;
24595 char *kwnames[] = {
24596 (char *) "self",(char *) "n", NULL
24597 };
24598
24599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24601 if (SWIG_arg_fail(1)) SWIG_fail;
24602 {
24603 arg2 = (int)(SWIG_As_int(obj1));
24604 if (SWIG_arg_fail(2)) SWIG_fail;
24605 }
24606 {
24607 PyThreadState* __tstate = wxPyBeginAllowThreads();
24608 result = wxTimeSpan___mul__(arg1,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___rmul__(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___rmul__",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___rmul__(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___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj;
24662 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24663 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24664 bool result;
24665 PyObject * obj0 = 0 ;
24666 PyObject * obj1 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self",(char *) "other", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24675 if (SWIG_arg_fail(2)) SWIG_fail;
24676 {
24677 PyThreadState* __tstate = wxPyBeginAllowThreads();
24678 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24679
24680 wxPyEndAllowThreads(__tstate);
24681 if (PyErr_Occurred()) SWIG_fail;
24682 }
24683 {
24684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24685 }
24686 return resultobj;
24687 fail:
24688 return NULL;
24689 }
24690
24691
24692 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24693 PyObject *resultobj;
24694 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24695 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24696 bool result;
24697 PyObject * obj0 = 0 ;
24698 PyObject * obj1 = 0 ;
24699 char *kwnames[] = {
24700 (char *) "self",(char *) "other", NULL
24701 };
24702
24703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24705 if (SWIG_arg_fail(1)) SWIG_fail;
24706 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24707 if (SWIG_arg_fail(2)) SWIG_fail;
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24711
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj;
24726 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24727 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24728 bool result;
24729 PyObject * obj0 = 0 ;
24730 PyObject * obj1 = 0 ;
24731 char *kwnames[] = {
24732 (char *) "self",(char *) "other", NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24737 if (SWIG_arg_fail(1)) SWIG_fail;
24738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24739 if (SWIG_arg_fail(2)) SWIG_fail;
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24743
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24757 PyObject *resultobj;
24758 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24759 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24760 bool result;
24761 PyObject * obj0 = 0 ;
24762 PyObject * obj1 = 0 ;
24763 char *kwnames[] = {
24764 (char *) "self",(char *) "other", NULL
24765 };
24766
24767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24769 if (SWIG_arg_fail(1)) SWIG_fail;
24770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24771 if (SWIG_arg_fail(2)) SWIG_fail;
24772 {
24773 PyThreadState* __tstate = wxPyBeginAllowThreads();
24774 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24775
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 {
24780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24781 }
24782 return resultobj;
24783 fail:
24784 return NULL;
24785 }
24786
24787
24788 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24789 PyObject *resultobj;
24790 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24791 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24792 bool result;
24793 PyObject * obj0 = 0 ;
24794 PyObject * obj1 = 0 ;
24795 char *kwnames[] = {
24796 (char *) "self",(char *) "other", NULL
24797 };
24798
24799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24801 if (SWIG_arg_fail(1)) SWIG_fail;
24802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24803 if (SWIG_arg_fail(2)) SWIG_fail;
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24807
24808 wxPyEndAllowThreads(__tstate);
24809 if (PyErr_Occurred()) SWIG_fail;
24810 }
24811 {
24812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24813 }
24814 return resultobj;
24815 fail:
24816 return NULL;
24817 }
24818
24819
24820 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24821 PyObject *resultobj;
24822 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24823 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24824 bool result;
24825 PyObject * obj0 = 0 ;
24826 PyObject * obj1 = 0 ;
24827 char *kwnames[] = {
24828 (char *) "self",(char *) "other", NULL
24829 };
24830
24831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24833 if (SWIG_arg_fail(1)) SWIG_fail;
24834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24835 if (SWIG_arg_fail(2)) SWIG_fail;
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 {
24844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24845 }
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj;
24854 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24855 bool result;
24856 PyObject * obj0 = 0 ;
24857 char *kwnames[] = {
24858 (char *) "self", NULL
24859 };
24860
24861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24863 if (SWIG_arg_fail(1)) SWIG_fail;
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24867
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 {
24872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24873 }
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24883 bool result;
24884 PyObject * obj0 = 0 ;
24885 char *kwnames[] = {
24886 (char *) "self", NULL
24887 };
24888
24889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24891 if (SWIG_arg_fail(1)) SWIG_fail;
24892 {
24893 PyThreadState* __tstate = wxPyBeginAllowThreads();
24894 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24895
24896 wxPyEndAllowThreads(__tstate);
24897 if (PyErr_Occurred()) SWIG_fail;
24898 }
24899 {
24900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24901 }
24902 return resultobj;
24903 fail:
24904 return NULL;
24905 }
24906
24907
24908 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24909 PyObject *resultobj;
24910 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24911 bool result;
24912 PyObject * obj0 = 0 ;
24913 char *kwnames[] = {
24914 (char *) "self", NULL
24915 };
24916
24917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24919 if (SWIG_arg_fail(1)) SWIG_fail;
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24923
24924 wxPyEndAllowThreads(__tstate);
24925 if (PyErr_Occurred()) SWIG_fail;
24926 }
24927 {
24928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24929 }
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24937 PyObject *resultobj;
24938 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24939 wxTimeSpan *arg2 = 0 ;
24940 bool result;
24941 PyObject * obj0 = 0 ;
24942 PyObject * obj1 = 0 ;
24943 char *kwnames[] = {
24944 (char *) "self",(char *) "ts", NULL
24945 };
24946
24947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24949 if (SWIG_arg_fail(1)) SWIG_fail;
24950 {
24951 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24952 if (SWIG_arg_fail(2)) SWIG_fail;
24953 if (arg2 == NULL) {
24954 SWIG_null_ref("wxTimeSpan");
24955 }
24956 if (SWIG_arg_fail(2)) SWIG_fail;
24957 }
24958 {
24959 PyThreadState* __tstate = wxPyBeginAllowThreads();
24960 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24961
24962 wxPyEndAllowThreads(__tstate);
24963 if (PyErr_Occurred()) SWIG_fail;
24964 }
24965 {
24966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24967 }
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj;
24976 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24977 wxTimeSpan *arg2 = 0 ;
24978 bool result;
24979 PyObject * obj0 = 0 ;
24980 PyObject * obj1 = 0 ;
24981 char *kwnames[] = {
24982 (char *) "self",(char *) "ts", NULL
24983 };
24984
24985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24987 if (SWIG_arg_fail(1)) SWIG_fail;
24988 {
24989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24990 if (SWIG_arg_fail(2)) SWIG_fail;
24991 if (arg2 == NULL) {
24992 SWIG_null_ref("wxTimeSpan");
24993 }
24994 if (SWIG_arg_fail(2)) SWIG_fail;
24995 }
24996 {
24997 PyThreadState* __tstate = wxPyBeginAllowThreads();
24998 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24999
25000 wxPyEndAllowThreads(__tstate);
25001 if (PyErr_Occurred()) SWIG_fail;
25002 }
25003 {
25004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25005 }
25006 return resultobj;
25007 fail:
25008 return NULL;
25009 }
25010
25011
25012 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
25013 PyObject *resultobj;
25014 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25015 wxTimeSpan *arg2 = 0 ;
25016 bool result;
25017 PyObject * obj0 = 0 ;
25018 PyObject * obj1 = 0 ;
25019 char *kwnames[] = {
25020 (char *) "self",(char *) "t", NULL
25021 };
25022
25023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
25024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25025 if (SWIG_arg_fail(1)) SWIG_fail;
25026 {
25027 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25028 if (SWIG_arg_fail(2)) SWIG_fail;
25029 if (arg2 == NULL) {
25030 SWIG_null_ref("wxTimeSpan");
25031 }
25032 if (SWIG_arg_fail(2)) SWIG_fail;
25033 }
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
25037
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj;
25052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25053 int result;
25054 PyObject * obj0 = 0 ;
25055 char *kwnames[] = {
25056 (char *) "self", NULL
25057 };
25058
25059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25065
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = SWIG_From_int((int)(result));
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25081 int result;
25082 PyObject * obj0 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 {
25098 resultobj = SWIG_From_int((int)(result));
25099 }
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj;
25108 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25109 int result;
25110 PyObject * obj0 = 0 ;
25111 char *kwnames[] = {
25112 (char *) "self", NULL
25113 };
25114
25115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25117 if (SWIG_arg_fail(1)) SWIG_fail;
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25121
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 {
25126 resultobj = SWIG_From_int((int)(result));
25127 }
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25135 PyObject *resultobj;
25136 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25137 int result;
25138 PyObject * obj0 = 0 ;
25139 char *kwnames[] = {
25140 (char *) "self", NULL
25141 };
25142
25143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25145 if (SWIG_arg_fail(1)) SWIG_fail;
25146 {
25147 PyThreadState* __tstate = wxPyBeginAllowThreads();
25148 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25149
25150 wxPyEndAllowThreads(__tstate);
25151 if (PyErr_Occurred()) SWIG_fail;
25152 }
25153 {
25154 resultobj = SWIG_From_int((int)(result));
25155 }
25156 return resultobj;
25157 fail:
25158 return NULL;
25159 }
25160
25161
25162 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25163 PyObject *resultobj;
25164 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25165 wxLongLong result;
25166 PyObject * obj0 = 0 ;
25167 char *kwnames[] = {
25168 (char *) "self", NULL
25169 };
25170
25171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25173 if (SWIG_arg_fail(1)) SWIG_fail;
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25177
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 PyObject *hi, *lo, *shifter, *shifted;
25183 hi = PyLong_FromLong( (&result)->GetHi() );
25184 lo = PyLong_FromLong( (&result)->GetLo() );
25185 shifter = PyLong_FromLong(32);
25186 shifted = PyNumber_Lshift(hi, shifter);
25187 resultobj = PyNumber_Or(shifted, lo);
25188 Py_DECREF(hi);
25189 Py_DECREF(lo);
25190 Py_DECREF(shifter);
25191 Py_DECREF(shifted);
25192 }
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj;
25201 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25202 wxLongLong result;
25203 PyObject * obj0 = 0 ;
25204 char *kwnames[] = {
25205 (char *) "self", NULL
25206 };
25207
25208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25210 if (SWIG_arg_fail(1)) SWIG_fail;
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25214
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 {
25219 PyObject *hi, *lo, *shifter, *shifted;
25220 hi = PyLong_FromLong( (&result)->GetHi() );
25221 lo = PyLong_FromLong( (&result)->GetLo() );
25222 shifter = PyLong_FromLong(32);
25223 shifted = PyNumber_Lshift(hi, shifter);
25224 resultobj = PyNumber_Or(shifted, lo);
25225 Py_DECREF(hi);
25226 Py_DECREF(lo);
25227 Py_DECREF(shifter);
25228 Py_DECREF(shifted);
25229 }
25230 return resultobj;
25231 fail:
25232 return NULL;
25233 }
25234
25235
25236 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25237 PyObject *resultobj;
25238 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25239 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25240 wxString *arg2 = (wxString *) &arg2_defvalue ;
25241 wxString result;
25242 bool temp2 = false ;
25243 PyObject * obj0 = 0 ;
25244 PyObject * obj1 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "self",(char *) "format", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25251 if (SWIG_arg_fail(1)) SWIG_fail;
25252 if (obj1) {
25253 {
25254 arg2 = wxString_in_helper(obj1);
25255 if (arg2 == NULL) SWIG_fail;
25256 temp2 = true;
25257 }
25258 }
25259 {
25260 PyThreadState* __tstate = wxPyBeginAllowThreads();
25261 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25262
25263 wxPyEndAllowThreads(__tstate);
25264 if (PyErr_Occurred()) SWIG_fail;
25265 }
25266 {
25267 #if wxUSE_UNICODE
25268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25269 #else
25270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25271 #endif
25272 }
25273 {
25274 if (temp2)
25275 delete arg2;
25276 }
25277 return resultobj;
25278 fail:
25279 {
25280 if (temp2)
25281 delete arg2;
25282 }
25283 return NULL;
25284 }
25285
25286
25287 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25288 PyObject *obj;
25289 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25290 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25291 Py_INCREF(obj);
25292 return Py_BuildValue((char *)"");
25293 }
25294 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj;
25296 int arg1 = (int) 0 ;
25297 int arg2 = (int) 0 ;
25298 int arg3 = (int) 0 ;
25299 int arg4 = (int) 0 ;
25300 wxDateSpan *result;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 PyObject * obj2 = 0 ;
25304 PyObject * obj3 = 0 ;
25305 char *kwnames[] = {
25306 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25307 };
25308
25309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25310 if (obj0) {
25311 {
25312 arg1 = (int)(SWIG_As_int(obj0));
25313 if (SWIG_arg_fail(1)) SWIG_fail;
25314 }
25315 }
25316 if (obj1) {
25317 {
25318 arg2 = (int)(SWIG_As_int(obj1));
25319 if (SWIG_arg_fail(2)) SWIG_fail;
25320 }
25321 }
25322 if (obj2) {
25323 {
25324 arg3 = (int)(SWIG_As_int(obj2));
25325 if (SWIG_arg_fail(3)) SWIG_fail;
25326 }
25327 }
25328 if (obj3) {
25329 {
25330 arg4 = (int)(SWIG_As_int(obj3));
25331 if (SWIG_arg_fail(4)) SWIG_fail;
25332 }
25333 }
25334 {
25335 PyThreadState* __tstate = wxPyBeginAllowThreads();
25336 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25337
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25342 return resultobj;
25343 fail:
25344 return NULL;
25345 }
25346
25347
25348 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25349 PyObject *resultobj;
25350 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25351 PyObject * obj0 = 0 ;
25352 char *kwnames[] = {
25353 (char *) "self", NULL
25354 };
25355
25356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25358 if (SWIG_arg_fail(1)) SWIG_fail;
25359 {
25360 PyThreadState* __tstate = wxPyBeginAllowThreads();
25361 delete arg1;
25362
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 Py_INCREF(Py_None); resultobj = Py_None;
25367 return resultobj;
25368 fail:
25369 return NULL;
25370 }
25371
25372
25373 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25374 PyObject *resultobj;
25375 int arg1 ;
25376 wxDateSpan result;
25377 PyObject * obj0 = 0 ;
25378 char *kwnames[] = {
25379 (char *) "days", NULL
25380 };
25381
25382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25383 {
25384 arg1 = (int)(SWIG_As_int(obj0));
25385 if (SWIG_arg_fail(1)) SWIG_fail;
25386 }
25387 {
25388 PyThreadState* __tstate = wxPyBeginAllowThreads();
25389 result = wxDateSpan::Days(arg1);
25390
25391 wxPyEndAllowThreads(__tstate);
25392 if (PyErr_Occurred()) SWIG_fail;
25393 }
25394 {
25395 wxDateSpan * resultptr;
25396 resultptr = new wxDateSpan((wxDateSpan &)(result));
25397 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25398 }
25399 return resultobj;
25400 fail:
25401 return NULL;
25402 }
25403
25404
25405 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25406 PyObject *resultobj;
25407 wxDateSpan result;
25408 char *kwnames[] = {
25409 NULL
25410 };
25411
25412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25413 {
25414 PyThreadState* __tstate = wxPyBeginAllowThreads();
25415 result = wxDateSpan::Day();
25416
25417 wxPyEndAllowThreads(__tstate);
25418 if (PyErr_Occurred()) SWIG_fail;
25419 }
25420 {
25421 wxDateSpan * resultptr;
25422 resultptr = new wxDateSpan((wxDateSpan &)(result));
25423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25424 }
25425 return resultobj;
25426 fail:
25427 return NULL;
25428 }
25429
25430
25431 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25432 PyObject *resultobj;
25433 int arg1 ;
25434 wxDateSpan result;
25435 PyObject * obj0 = 0 ;
25436 char *kwnames[] = {
25437 (char *) "weeks", NULL
25438 };
25439
25440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25441 {
25442 arg1 = (int)(SWIG_As_int(obj0));
25443 if (SWIG_arg_fail(1)) SWIG_fail;
25444 }
25445 {
25446 PyThreadState* __tstate = wxPyBeginAllowThreads();
25447 result = wxDateSpan::Weeks(arg1);
25448
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 {
25453 wxDateSpan * resultptr;
25454 resultptr = new wxDateSpan((wxDateSpan &)(result));
25455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25456 }
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj;
25465 wxDateSpan result;
25466 char *kwnames[] = {
25467 NULL
25468 };
25469
25470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25471 {
25472 PyThreadState* __tstate = wxPyBeginAllowThreads();
25473 result = wxDateSpan::Week();
25474
25475 wxPyEndAllowThreads(__tstate);
25476 if (PyErr_Occurred()) SWIG_fail;
25477 }
25478 {
25479 wxDateSpan * resultptr;
25480 resultptr = new wxDateSpan((wxDateSpan &)(result));
25481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25482 }
25483 return resultobj;
25484 fail:
25485 return NULL;
25486 }
25487
25488
25489 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25490 PyObject *resultobj;
25491 int arg1 ;
25492 wxDateSpan result;
25493 PyObject * obj0 = 0 ;
25494 char *kwnames[] = {
25495 (char *) "mon", NULL
25496 };
25497
25498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25499 {
25500 arg1 = (int)(SWIG_As_int(obj0));
25501 if (SWIG_arg_fail(1)) SWIG_fail;
25502 }
25503 {
25504 PyThreadState* __tstate = wxPyBeginAllowThreads();
25505 result = wxDateSpan::Months(arg1);
25506
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 {
25511 wxDateSpan * resultptr;
25512 resultptr = new wxDateSpan((wxDateSpan &)(result));
25513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25514 }
25515 return resultobj;
25516 fail:
25517 return NULL;
25518 }
25519
25520
25521 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25522 PyObject *resultobj;
25523 wxDateSpan result;
25524 char *kwnames[] = {
25525 NULL
25526 };
25527
25528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 result = wxDateSpan::Month();
25532
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 {
25537 wxDateSpan * resultptr;
25538 resultptr = new wxDateSpan((wxDateSpan &)(result));
25539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25540 }
25541 return resultobj;
25542 fail:
25543 return NULL;
25544 }
25545
25546
25547 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25548 PyObject *resultobj;
25549 int arg1 ;
25550 wxDateSpan result;
25551 PyObject * obj0 = 0 ;
25552 char *kwnames[] = {
25553 (char *) "years", NULL
25554 };
25555
25556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25557 {
25558 arg1 = (int)(SWIG_As_int(obj0));
25559 if (SWIG_arg_fail(1)) SWIG_fail;
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 result = wxDateSpan::Years(arg1);
25564
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 {
25569 wxDateSpan * resultptr;
25570 resultptr = new wxDateSpan((wxDateSpan &)(result));
25571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25572 }
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25580 PyObject *resultobj;
25581 wxDateSpan result;
25582 char *kwnames[] = {
25583 NULL
25584 };
25585
25586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = wxDateSpan::Year();
25590
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 {
25595 wxDateSpan * resultptr;
25596 resultptr = new wxDateSpan((wxDateSpan &)(result));
25597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25598 }
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25606 PyObject *resultobj;
25607 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25608 int arg2 ;
25609 wxDateSpan *result;
25610 PyObject * obj0 = 0 ;
25611 PyObject * obj1 = 0 ;
25612 char *kwnames[] = {
25613 (char *) "self",(char *) "n", NULL
25614 };
25615
25616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25618 if (SWIG_arg_fail(1)) SWIG_fail;
25619 {
25620 arg2 = (int)(SWIG_As_int(obj1));
25621 if (SWIG_arg_fail(2)) SWIG_fail;
25622 }
25623 {
25624 PyThreadState* __tstate = wxPyBeginAllowThreads();
25625 {
25626 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25627 result = (wxDateSpan *) &_result_ref;
25628 }
25629
25630 wxPyEndAllowThreads(__tstate);
25631 if (PyErr_Occurred()) SWIG_fail;
25632 }
25633 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25641 PyObject *resultobj;
25642 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25643 int arg2 ;
25644 wxDateSpan *result;
25645 PyObject * obj0 = 0 ;
25646 PyObject * obj1 = 0 ;
25647 char *kwnames[] = {
25648 (char *) "self",(char *) "n", NULL
25649 };
25650
25651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25653 if (SWIG_arg_fail(1)) SWIG_fail;
25654 {
25655 arg2 = (int)(SWIG_As_int(obj1));
25656 if (SWIG_arg_fail(2)) SWIG_fail;
25657 }
25658 {
25659 PyThreadState* __tstate = wxPyBeginAllowThreads();
25660 {
25661 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25662 result = (wxDateSpan *) &_result_ref;
25663 }
25664
25665 wxPyEndAllowThreads(__tstate);
25666 if (PyErr_Occurred()) SWIG_fail;
25667 }
25668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25676 PyObject *resultobj;
25677 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25678 int arg2 ;
25679 wxDateSpan *result;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char *kwnames[] = {
25683 (char *) "self",(char *) "n", NULL
25684 };
25685
25686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(1)) SWIG_fail;
25689 {
25690 arg2 = (int)(SWIG_As_int(obj1));
25691 if (SWIG_arg_fail(2)) SWIG_fail;
25692 }
25693 {
25694 PyThreadState* __tstate = wxPyBeginAllowThreads();
25695 {
25696 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25697 result = (wxDateSpan *) &_result_ref;
25698 }
25699
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25713 int arg2 ;
25714 wxDateSpan *result;
25715 PyObject * obj0 = 0 ;
25716 PyObject * obj1 = 0 ;
25717 char *kwnames[] = {
25718 (char *) "self",(char *) "n", NULL
25719 };
25720
25721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25723 if (SWIG_arg_fail(1)) SWIG_fail;
25724 {
25725 arg2 = (int)(SWIG_As_int(obj1));
25726 if (SWIG_arg_fail(2)) SWIG_fail;
25727 }
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 {
25731 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25732 result = (wxDateSpan *) &_result_ref;
25733 }
25734
25735 wxPyEndAllowThreads(__tstate);
25736 if (PyErr_Occurred()) SWIG_fail;
25737 }
25738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj;
25747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25748 int result;
25749 PyObject * obj0 = 0 ;
25750 char *kwnames[] = {
25751 (char *) "self", NULL
25752 };
25753
25754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25756 if (SWIG_arg_fail(1)) SWIG_fail;
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 result = (int)((wxDateSpan const *)arg1)->GetYears();
25760
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 {
25765 resultobj = SWIG_From_int((int)(result));
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj;
25775 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25776 int result;
25777 PyObject * obj0 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self", NULL
25780 };
25781
25782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25784 if (SWIG_arg_fail(1)) SWIG_fail;
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = SWIG_From_int((int)(result));
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25804 int result;
25805 PyObject * obj0 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 {
25821 resultobj = SWIG_From_int((int)(result));
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25830 PyObject *resultobj;
25831 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25832 int result;
25833 PyObject * obj0 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 PyThreadState* __tstate = wxPyBeginAllowThreads();
25843 result = (int)((wxDateSpan const *)arg1)->GetDays();
25844
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 {
25849 resultobj = SWIG_From_int((int)(result));
25850 }
25851 return resultobj;
25852 fail:
25853 return NULL;
25854 }
25855
25856
25857 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25858 PyObject *resultobj;
25859 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25860 int result;
25861 PyObject * obj0 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 PyThreadState* __tstate = wxPyBeginAllowThreads();
25871 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25872
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 {
25877 resultobj = SWIG_From_int((int)(result));
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25886 PyObject *resultobj;
25887 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25888 wxDateSpan *arg2 = 0 ;
25889 wxDateSpan *result;
25890 PyObject * obj0 = 0 ;
25891 PyObject * obj1 = 0 ;
25892 char *kwnames[] = {
25893 (char *) "self",(char *) "other", NULL
25894 };
25895
25896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25898 if (SWIG_arg_fail(1)) SWIG_fail;
25899 {
25900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25901 if (SWIG_arg_fail(2)) SWIG_fail;
25902 if (arg2 == NULL) {
25903 SWIG_null_ref("wxDateSpan");
25904 }
25905 if (SWIG_arg_fail(2)) SWIG_fail;
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 {
25910 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25911 result = (wxDateSpan *) &_result_ref;
25912 }
25913
25914 wxPyEndAllowThreads(__tstate);
25915 if (PyErr_Occurred()) SWIG_fail;
25916 }
25917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25918 return resultobj;
25919 fail:
25920 return NULL;
25921 }
25922
25923
25924 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25925 PyObject *resultobj;
25926 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25927 wxDateSpan *arg2 = 0 ;
25928 wxDateSpan *result;
25929 PyObject * obj0 = 0 ;
25930 PyObject * obj1 = 0 ;
25931 char *kwnames[] = {
25932 (char *) "self",(char *) "other", NULL
25933 };
25934
25935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(1)) SWIG_fail;
25938 {
25939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25940 if (SWIG_arg_fail(2)) SWIG_fail;
25941 if (arg2 == NULL) {
25942 SWIG_null_ref("wxDateSpan");
25943 }
25944 if (SWIG_arg_fail(2)) SWIG_fail;
25945 }
25946 {
25947 PyThreadState* __tstate = wxPyBeginAllowThreads();
25948 {
25949 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25950 result = (wxDateSpan *) &_result_ref;
25951 }
25952
25953 wxPyEndAllowThreads(__tstate);
25954 if (PyErr_Occurred()) SWIG_fail;
25955 }
25956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj;
25965 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25966 wxDateSpan *result;
25967 PyObject * obj0 = 0 ;
25968 char *kwnames[] = {
25969 (char *) "self", NULL
25970 };
25971
25972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25974 if (SWIG_arg_fail(1)) SWIG_fail;
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 {
25978 wxDateSpan &_result_ref = (arg1)->Neg();
25979 result = (wxDateSpan *) &_result_ref;
25980 }
25981
25982 wxPyEndAllowThreads(__tstate);
25983 if (PyErr_Occurred()) SWIG_fail;
25984 }
25985 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25986 return resultobj;
25987 fail:
25988 return NULL;
25989 }
25990
25991
25992 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25993 PyObject *resultobj;
25994 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25995 int arg2 ;
25996 wxDateSpan *result;
25997 PyObject * obj0 = 0 ;
25998 PyObject * obj1 = 0 ;
25999 char *kwnames[] = {
26000 (char *) "self",(char *) "factor", NULL
26001 };
26002
26003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
26004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26005 if (SWIG_arg_fail(1)) SWIG_fail;
26006 {
26007 arg2 = (int)(SWIG_As_int(obj1));
26008 if (SWIG_arg_fail(2)) SWIG_fail;
26009 }
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 {
26013 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
26014 result = (wxDateSpan *) &_result_ref;
26015 }
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
26028 PyObject *resultobj;
26029 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26030 wxDateSpan *arg2 = 0 ;
26031 wxDateSpan *result;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self",(char *) "other", NULL
26036 };
26037
26038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
26039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26040 if (SWIG_arg_fail(1)) SWIG_fail;
26041 {
26042 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26043 if (SWIG_arg_fail(2)) SWIG_fail;
26044 if (arg2 == NULL) {
26045 SWIG_null_ref("wxDateSpan");
26046 }
26047 if (SWIG_arg_fail(2)) SWIG_fail;
26048 }
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 {
26052 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
26053 result = (wxDateSpan *) &_result_ref;
26054 }
26055
26056 wxPyEndAllowThreads(__tstate);
26057 if (PyErr_Occurred()) SWIG_fail;
26058 }
26059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26060 return resultobj;
26061 fail:
26062 return NULL;
26063 }
26064
26065
26066 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26067 PyObject *resultobj;
26068 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26069 wxDateSpan *arg2 = 0 ;
26070 wxDateSpan *result;
26071 PyObject * obj0 = 0 ;
26072 PyObject * obj1 = 0 ;
26073 char *kwnames[] = {
26074 (char *) "self",(char *) "other", NULL
26075 };
26076
26077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26079 if (SWIG_arg_fail(1)) SWIG_fail;
26080 {
26081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26082 if (SWIG_arg_fail(2)) SWIG_fail;
26083 if (arg2 == NULL) {
26084 SWIG_null_ref("wxDateSpan");
26085 }
26086 if (SWIG_arg_fail(2)) SWIG_fail;
26087 }
26088 {
26089 PyThreadState* __tstate = wxPyBeginAllowThreads();
26090 {
26091 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26092 result = (wxDateSpan *) &_result_ref;
26093 }
26094
26095 wxPyEndAllowThreads(__tstate);
26096 if (PyErr_Occurred()) SWIG_fail;
26097 }
26098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26099 return resultobj;
26100 fail:
26101 return NULL;
26102 }
26103
26104
26105 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26106 PyObject *resultobj;
26107 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26108 wxDateSpan *result;
26109 PyObject * obj0 = 0 ;
26110 char *kwnames[] = {
26111 (char *) "self", NULL
26112 };
26113
26114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26116 if (SWIG_arg_fail(1)) SWIG_fail;
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 {
26120 wxDateSpan &_result_ref = (arg1)->operator -();
26121 result = (wxDateSpan *) &_result_ref;
26122 }
26123
26124 wxPyEndAllowThreads(__tstate);
26125 if (PyErr_Occurred()) SWIG_fail;
26126 }
26127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26128 return resultobj;
26129 fail:
26130 return NULL;
26131 }
26132
26133
26134 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26135 PyObject *resultobj;
26136 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26137 int arg2 ;
26138 wxDateSpan *result;
26139 PyObject * obj0 = 0 ;
26140 PyObject * obj1 = 0 ;
26141 char *kwnames[] = {
26142 (char *) "self",(char *) "factor", NULL
26143 };
26144
26145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26147 if (SWIG_arg_fail(1)) SWIG_fail;
26148 {
26149 arg2 = (int)(SWIG_As_int(obj1));
26150 if (SWIG_arg_fail(2)) SWIG_fail;
26151 }
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 {
26155 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26156 result = (wxDateSpan *) &_result_ref;
26157 }
26158
26159 wxPyEndAllowThreads(__tstate);
26160 if (PyErr_Occurred()) SWIG_fail;
26161 }
26162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26163 return resultobj;
26164 fail:
26165 return NULL;
26166 }
26167
26168
26169 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26170 PyObject *resultobj;
26171 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26172 wxDateSpan *arg2 = 0 ;
26173 wxDateSpan result;
26174 PyObject * obj0 = 0 ;
26175 PyObject * obj1 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self",(char *) "other", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26182 if (SWIG_arg_fail(1)) SWIG_fail;
26183 {
26184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26185 if (SWIG_arg_fail(2)) SWIG_fail;
26186 if (arg2 == NULL) {
26187 SWIG_null_ref("wxDateSpan");
26188 }
26189 if (SWIG_arg_fail(2)) SWIG_fail;
26190 }
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26194
26195 wxPyEndAllowThreads(__tstate);
26196 if (PyErr_Occurred()) SWIG_fail;
26197 }
26198 {
26199 wxDateSpan * resultptr;
26200 resultptr = new wxDateSpan((wxDateSpan &)(result));
26201 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26202 }
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26210 PyObject *resultobj;
26211 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26212 wxDateSpan *arg2 = 0 ;
26213 wxDateSpan result;
26214 PyObject * obj0 = 0 ;
26215 PyObject * obj1 = 0 ;
26216 char *kwnames[] = {
26217 (char *) "self",(char *) "other", NULL
26218 };
26219
26220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26222 if (SWIG_arg_fail(1)) SWIG_fail;
26223 {
26224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26225 if (SWIG_arg_fail(2)) SWIG_fail;
26226 if (arg2 == NULL) {
26227 SWIG_null_ref("wxDateSpan");
26228 }
26229 if (SWIG_arg_fail(2)) SWIG_fail;
26230 }
26231 {
26232 PyThreadState* __tstate = wxPyBeginAllowThreads();
26233 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26234
26235 wxPyEndAllowThreads(__tstate);
26236 if (PyErr_Occurred()) SWIG_fail;
26237 }
26238 {
26239 wxDateSpan * resultptr;
26240 resultptr = new wxDateSpan((wxDateSpan &)(result));
26241 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26242 }
26243 return resultobj;
26244 fail:
26245 return NULL;
26246 }
26247
26248
26249 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26250 PyObject *resultobj;
26251 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26252 int arg2 ;
26253 wxDateSpan result;
26254 PyObject * obj0 = 0 ;
26255 PyObject * obj1 = 0 ;
26256 char *kwnames[] = {
26257 (char *) "self",(char *) "n", NULL
26258 };
26259
26260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26262 if (SWIG_arg_fail(1)) SWIG_fail;
26263 {
26264 arg2 = (int)(SWIG_As_int(obj1));
26265 if (SWIG_arg_fail(2)) SWIG_fail;
26266 }
26267 {
26268 PyThreadState* __tstate = wxPyBeginAllowThreads();
26269 result = wxDateSpan___mul__(arg1,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___rmul__(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___rmul__",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___rmul__(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___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26322 PyObject *resultobj;
26323 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26324 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26325 bool result;
26326 PyObject * obj0 = 0 ;
26327 PyObject * obj1 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self",(char *) "other", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26336 if (SWIG_arg_fail(2)) SWIG_fail;
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 {
26345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26346 }
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj;
26355 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26356 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26357 bool result;
26358 PyObject * obj0 = 0 ;
26359 PyObject * obj1 = 0 ;
26360 char *kwnames[] = {
26361 (char *) "self",(char *) "other", NULL
26362 };
26363
26364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26366 if (SWIG_arg_fail(1)) SWIG_fail;
26367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26368 if (SWIG_arg_fail(2)) SWIG_fail;
26369 {
26370 PyThreadState* __tstate = wxPyBeginAllowThreads();
26371 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26372
26373 wxPyEndAllowThreads(__tstate);
26374 if (PyErr_Occurred()) SWIG_fail;
26375 }
26376 {
26377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26386 PyObject *obj;
26387 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26388 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26389 Py_INCREF(obj);
26390 return Py_BuildValue((char *)"");
26391 }
26392 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26393 PyObject *resultobj;
26394 long result;
26395 char *kwnames[] = {
26396 NULL
26397 };
26398
26399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 result = (long)wxGetLocalTime();
26403
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 {
26408 resultobj = SWIG_From_long((long)(result));
26409 }
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj;
26418 long result;
26419 char *kwnames[] = {
26420 NULL
26421 };
26422
26423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26424 {
26425 PyThreadState* __tstate = wxPyBeginAllowThreads();
26426 result = (long)wxGetUTCTime();
26427
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 {
26432 resultobj = SWIG_From_long((long)(result));
26433 }
26434 return resultobj;
26435 fail:
26436 return NULL;
26437 }
26438
26439
26440 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26441 PyObject *resultobj;
26442 long result;
26443 char *kwnames[] = {
26444 NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26448 {
26449 PyThreadState* __tstate = wxPyBeginAllowThreads();
26450 result = (long)wxGetCurrentTime();
26451
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 {
26456 resultobj = SWIG_From_long((long)(result));
26457 }
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj;
26466 wxLongLong result;
26467 char *kwnames[] = {
26468 NULL
26469 };
26470
26471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26472 {
26473 PyThreadState* __tstate = wxPyBeginAllowThreads();
26474 result = wxGetLocalTimeMillis();
26475
26476 wxPyEndAllowThreads(__tstate);
26477 if (PyErr_Occurred()) SWIG_fail;
26478 }
26479 {
26480 PyObject *hi, *lo, *shifter, *shifted;
26481 hi = PyLong_FromLong( (&result)->GetHi() );
26482 lo = PyLong_FromLong( (&result)->GetLo() );
26483 shifter = PyLong_FromLong(32);
26484 shifted = PyNumber_Lshift(hi, shifter);
26485 resultobj = PyNumber_Or(shifted, lo);
26486 Py_DECREF(hi);
26487 Py_DECREF(lo);
26488 Py_DECREF(shifter);
26489 Py_DECREF(shifted);
26490 }
26491 return resultobj;
26492 fail:
26493 return NULL;
26494 }
26495
26496
26497 static int _wrap_DefaultDateTime_set(PyObject *) {
26498 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26499 return 1;
26500 }
26501
26502
26503 static PyObject *_wrap_DefaultDateTime_get(void) {
26504 PyObject *pyobj;
26505
26506 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26507 return pyobj;
26508 }
26509
26510
26511 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26512 PyObject *resultobj;
26513 wxDataFormatId arg1 ;
26514 wxDataFormat *result;
26515 PyObject * obj0 = 0 ;
26516 char *kwnames[] = {
26517 (char *) "type", NULL
26518 };
26519
26520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26521 {
26522 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26523 if (SWIG_arg_fail(1)) SWIG_fail;
26524 }
26525 {
26526 PyThreadState* __tstate = wxPyBeginAllowThreads();
26527 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26528
26529 wxPyEndAllowThreads(__tstate);
26530 if (PyErr_Occurred()) SWIG_fail;
26531 }
26532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26533 return resultobj;
26534 fail:
26535 return NULL;
26536 }
26537
26538
26539 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26540 PyObject *resultobj;
26541 wxString *arg1 = 0 ;
26542 wxDataFormat *result;
26543 bool temp1 = false ;
26544 PyObject * obj0 = 0 ;
26545 char *kwnames[] = {
26546 (char *) "format", NULL
26547 };
26548
26549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26550 {
26551 arg1 = wxString_in_helper(obj0);
26552 if (arg1 == NULL) SWIG_fail;
26553 temp1 = true;
26554 }
26555 {
26556 PyThreadState* __tstate = wxPyBeginAllowThreads();
26557 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26558
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26563 {
26564 if (temp1)
26565 delete arg1;
26566 }
26567 return resultobj;
26568 fail:
26569 {
26570 if (temp1)
26571 delete arg1;
26572 }
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26578 PyObject *resultobj;
26579 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26580 PyObject * obj0 = 0 ;
26581 char *kwnames[] = {
26582 (char *) "self", NULL
26583 };
26584
26585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26587 if (SWIG_arg_fail(1)) SWIG_fail;
26588 {
26589 PyThreadState* __tstate = wxPyBeginAllowThreads();
26590 delete arg1;
26591
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 Py_INCREF(Py_None); resultobj = Py_None;
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26603 PyObject *resultobj;
26604 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26605 wxDataFormatId arg2 ;
26606 bool result;
26607 PyObject * obj0 = 0 ;
26608 PyObject * obj1 = 0 ;
26609
26610 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26612 if (SWIG_arg_fail(1)) SWIG_fail;
26613 {
26614 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26615 if (SWIG_arg_fail(2)) SWIG_fail;
26616 }
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26620
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 {
26625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26626 }
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26634 PyObject *resultobj;
26635 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26636 wxDataFormatId arg2 ;
26637 bool result;
26638 PyObject * obj0 = 0 ;
26639 PyObject * obj1 = 0 ;
26640
26641 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26643 if (SWIG_arg_fail(1)) SWIG_fail;
26644 {
26645 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26646 if (SWIG_arg_fail(2)) SWIG_fail;
26647 }
26648 {
26649 PyThreadState* __tstate = wxPyBeginAllowThreads();
26650 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26651
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 {
26656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26657 }
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26665 PyObject *resultobj;
26666 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26667 wxDataFormat *arg2 = 0 ;
26668 bool result;
26669 PyObject * obj0 = 0 ;
26670 PyObject * obj1 = 0 ;
26671
26672 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26674 if (SWIG_arg_fail(1)) SWIG_fail;
26675 {
26676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26677 if (SWIG_arg_fail(2)) SWIG_fail;
26678 if (arg2 == NULL) {
26679 SWIG_null_ref("wxDataFormat");
26680 }
26681 if (SWIG_arg_fail(2)) SWIG_fail;
26682 }
26683 {
26684 PyThreadState* __tstate = wxPyBeginAllowThreads();
26685 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26686
26687 wxPyEndAllowThreads(__tstate);
26688 if (PyErr_Occurred()) SWIG_fail;
26689 }
26690 {
26691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26692 }
26693 return resultobj;
26694 fail:
26695 return NULL;
26696 }
26697
26698
26699 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26700 int argc;
26701 PyObject *argv[3];
26702 int ii;
26703
26704 argc = PyObject_Length(args);
26705 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26706 argv[ii] = PyTuple_GetItem(args,ii);
26707 }
26708 if (argc == 2) {
26709 int _v;
26710 {
26711 void *ptr;
26712 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26713 _v = 0;
26714 PyErr_Clear();
26715 } else {
26716 _v = 1;
26717 }
26718 }
26719 if (_v) {
26720 {
26721 void *ptr = 0;
26722 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26723 _v = 0;
26724 PyErr_Clear();
26725 } else {
26726 _v = (ptr != 0);
26727 }
26728 }
26729 if (_v) {
26730 return _wrap_DataFormat___eq____SWIG_1(self,args);
26731 }
26732 }
26733 }
26734 if (argc == 2) {
26735 int _v;
26736 {
26737 void *ptr;
26738 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26739 _v = 0;
26740 PyErr_Clear();
26741 } else {
26742 _v = 1;
26743 }
26744 }
26745 if (_v) {
26746 _v = SWIG_Check_int(argv[1]);
26747 if (_v) {
26748 return _wrap_DataFormat___eq____SWIG_0(self,args);
26749 }
26750 }
26751 }
26752
26753 Py_INCREF(Py_NotImplemented);
26754 return Py_NotImplemented;
26755 }
26756
26757
26758 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26759 PyObject *resultobj;
26760 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26761 wxDataFormat *arg2 = 0 ;
26762 bool result;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765
26766 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26768 if (SWIG_arg_fail(1)) SWIG_fail;
26769 {
26770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26771 if (SWIG_arg_fail(2)) SWIG_fail;
26772 if (arg2 == NULL) {
26773 SWIG_null_ref("wxDataFormat");
26774 }
26775 if (SWIG_arg_fail(2)) SWIG_fail;
26776 }
26777 {
26778 PyThreadState* __tstate = wxPyBeginAllowThreads();
26779 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26780
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 {
26785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26786 }
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26794 int argc;
26795 PyObject *argv[3];
26796 int ii;
26797
26798 argc = PyObject_Length(args);
26799 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26800 argv[ii] = PyTuple_GetItem(args,ii);
26801 }
26802 if (argc == 2) {
26803 int _v;
26804 {
26805 void *ptr;
26806 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26807 _v = 0;
26808 PyErr_Clear();
26809 } else {
26810 _v = 1;
26811 }
26812 }
26813 if (_v) {
26814 {
26815 void *ptr = 0;
26816 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26817 _v = 0;
26818 PyErr_Clear();
26819 } else {
26820 _v = (ptr != 0);
26821 }
26822 }
26823 if (_v) {
26824 return _wrap_DataFormat___ne____SWIG_1(self,args);
26825 }
26826 }
26827 }
26828 if (argc == 2) {
26829 int _v;
26830 {
26831 void *ptr;
26832 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26833 _v = 0;
26834 PyErr_Clear();
26835 } else {
26836 _v = 1;
26837 }
26838 }
26839 if (_v) {
26840 _v = SWIG_Check_int(argv[1]);
26841 if (_v) {
26842 return _wrap_DataFormat___ne____SWIG_0(self,args);
26843 }
26844 }
26845 }
26846
26847 Py_INCREF(Py_NotImplemented);
26848 return Py_NotImplemented;
26849 }
26850
26851
26852 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26853 PyObject *resultobj;
26854 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26855 wxDataFormatId arg2 ;
26856 PyObject * obj0 = 0 ;
26857 PyObject * obj1 = 0 ;
26858 char *kwnames[] = {
26859 (char *) "self",(char *) "format", NULL
26860 };
26861
26862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26864 if (SWIG_arg_fail(1)) SWIG_fail;
26865 {
26866 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26867 if (SWIG_arg_fail(2)) SWIG_fail;
26868 }
26869 {
26870 PyThreadState* __tstate = wxPyBeginAllowThreads();
26871 (arg1)->SetType((wxDataFormatId )arg2);
26872
26873 wxPyEndAllowThreads(__tstate);
26874 if (PyErr_Occurred()) SWIG_fail;
26875 }
26876 Py_INCREF(Py_None); resultobj = Py_None;
26877 return resultobj;
26878 fail:
26879 return NULL;
26880 }
26881
26882
26883 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26884 PyObject *resultobj;
26885 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26886 wxDataFormatId result;
26887 PyObject * obj0 = 0 ;
26888 char *kwnames[] = {
26889 (char *) "self", NULL
26890 };
26891
26892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26894 if (SWIG_arg_fail(1)) SWIG_fail;
26895 {
26896 PyThreadState* __tstate = wxPyBeginAllowThreads();
26897 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26898
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 resultobj = SWIG_From_int((result));
26903 return resultobj;
26904 fail:
26905 return NULL;
26906 }
26907
26908
26909 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26910 PyObject *resultobj;
26911 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26912 wxString result;
26913 PyObject * obj0 = 0 ;
26914 char *kwnames[] = {
26915 (char *) "self", NULL
26916 };
26917
26918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26920 if (SWIG_arg_fail(1)) SWIG_fail;
26921 {
26922 PyThreadState* __tstate = wxPyBeginAllowThreads();
26923 result = ((wxDataFormat const *)arg1)->GetId();
26924
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 #if wxUSE_UNICODE
26930 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26931 #else
26932 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26933 #endif
26934 }
26935 return resultobj;
26936 fail:
26937 return NULL;
26938 }
26939
26940
26941 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26942 PyObject *resultobj;
26943 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26944 wxString *arg2 = 0 ;
26945 bool temp2 = false ;
26946 PyObject * obj0 = 0 ;
26947 PyObject * obj1 = 0 ;
26948 char *kwnames[] = {
26949 (char *) "self",(char *) "format", NULL
26950 };
26951
26952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26954 if (SWIG_arg_fail(1)) SWIG_fail;
26955 {
26956 arg2 = wxString_in_helper(obj1);
26957 if (arg2 == NULL) SWIG_fail;
26958 temp2 = true;
26959 }
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 (arg1)->SetId((wxString const &)*arg2);
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 Py_INCREF(Py_None); resultobj = Py_None;
26968 {
26969 if (temp2)
26970 delete arg2;
26971 }
26972 return resultobj;
26973 fail:
26974 {
26975 if (temp2)
26976 delete arg2;
26977 }
26978 return NULL;
26979 }
26980
26981
26982 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26983 PyObject *obj;
26984 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26985 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26986 Py_INCREF(obj);
26987 return Py_BuildValue((char *)"");
26988 }
26989 static int _wrap_FormatInvalid_set(PyObject *) {
26990 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26991 return 1;
26992 }
26993
26994
26995 static PyObject *_wrap_FormatInvalid_get(void) {
26996 PyObject *pyobj;
26997
26998 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26999 return pyobj;
27000 }
27001
27002
27003 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27004 PyObject *resultobj;
27005 wxDataObject *arg1 = (wxDataObject *) 0 ;
27006 PyObject * obj0 = 0 ;
27007 char *kwnames[] = {
27008 (char *) "self", NULL
27009 };
27010
27011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
27012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27013 if (SWIG_arg_fail(1)) SWIG_fail;
27014 {
27015 PyThreadState* __tstate = wxPyBeginAllowThreads();
27016 delete arg1;
27017
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 Py_INCREF(Py_None); resultobj = Py_None;
27022 return resultobj;
27023 fail:
27024 return NULL;
27025 }
27026
27027
27028 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27029 PyObject *resultobj;
27030 wxDataObject *arg1 = (wxDataObject *) 0 ;
27031 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27032 SwigValueWrapper<wxDataFormat > result;
27033 PyObject * obj0 = 0 ;
27034 PyObject * obj1 = 0 ;
27035 char *kwnames[] = {
27036 (char *) "self",(char *) "dir", NULL
27037 };
27038
27039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
27040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 if (obj1) {
27043 {
27044 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27045 if (SWIG_arg_fail(2)) SWIG_fail;
27046 }
27047 }
27048 {
27049 PyThreadState* __tstate = wxPyBeginAllowThreads();
27050 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
27051
27052 wxPyEndAllowThreads(__tstate);
27053 if (PyErr_Occurred()) SWIG_fail;
27054 }
27055 {
27056 wxDataFormat * resultptr;
27057 resultptr = new wxDataFormat((wxDataFormat &)(result));
27058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27059 }
27060 return resultobj;
27061 fail:
27062 return NULL;
27063 }
27064
27065
27066 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27067 PyObject *resultobj;
27068 wxDataObject *arg1 = (wxDataObject *) 0 ;
27069 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27070 size_t result;
27071 PyObject * obj0 = 0 ;
27072 PyObject * obj1 = 0 ;
27073 char *kwnames[] = {
27074 (char *) "self",(char *) "dir", NULL
27075 };
27076
27077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(1)) SWIG_fail;
27080 if (obj1) {
27081 {
27082 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27083 if (SWIG_arg_fail(2)) SWIG_fail;
27084 }
27085 }
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27089
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 {
27094 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27095 }
27096 return resultobj;
27097 fail:
27098 return NULL;
27099 }
27100
27101
27102 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27103 PyObject *resultobj;
27104 wxDataObject *arg1 = (wxDataObject *) 0 ;
27105 wxDataFormat *arg2 = 0 ;
27106 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27107 bool result;
27108 PyObject * obj0 = 0 ;
27109 PyObject * obj1 = 0 ;
27110 PyObject * obj2 = 0 ;
27111 char *kwnames[] = {
27112 (char *) "self",(char *) "format",(char *) "dir", NULL
27113 };
27114
27115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27117 if (SWIG_arg_fail(1)) SWIG_fail;
27118 {
27119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27120 if (SWIG_arg_fail(2)) SWIG_fail;
27121 if (arg2 == NULL) {
27122 SWIG_null_ref("wxDataFormat");
27123 }
27124 if (SWIG_arg_fail(2)) SWIG_fail;
27125 }
27126 if (obj2) {
27127 {
27128 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27129 if (SWIG_arg_fail(3)) SWIG_fail;
27130 }
27131 }
27132 {
27133 PyThreadState* __tstate = wxPyBeginAllowThreads();
27134 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27135
27136 wxPyEndAllowThreads(__tstate);
27137 if (PyErr_Occurred()) SWIG_fail;
27138 }
27139 {
27140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27141 }
27142 return resultobj;
27143 fail:
27144 return NULL;
27145 }
27146
27147
27148 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27149 PyObject *resultobj;
27150 wxDataObject *arg1 = (wxDataObject *) 0 ;
27151 wxDataFormat *arg2 = 0 ;
27152 size_t result;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char *kwnames[] = {
27156 (char *) "self",(char *) "format", NULL
27157 };
27158
27159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27161 if (SWIG_arg_fail(1)) SWIG_fail;
27162 {
27163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27164 if (SWIG_arg_fail(2)) SWIG_fail;
27165 if (arg2 == NULL) {
27166 SWIG_null_ref("wxDataFormat");
27167 }
27168 if (SWIG_arg_fail(2)) SWIG_fail;
27169 }
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27173
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 {
27178 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27179 }
27180 return resultobj;
27181 fail:
27182 return NULL;
27183 }
27184
27185
27186 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27187 PyObject *resultobj;
27188 wxDataObject *arg1 = (wxDataObject *) 0 ;
27189 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27190 PyObject *result;
27191 PyObject * obj0 = 0 ;
27192 PyObject * obj1 = 0 ;
27193 char *kwnames[] = {
27194 (char *) "self",(char *) "dir", NULL
27195 };
27196
27197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27199 if (SWIG_arg_fail(1)) SWIG_fail;
27200 if (obj1) {
27201 {
27202 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27203 if (SWIG_arg_fail(2)) SWIG_fail;
27204 }
27205 }
27206 {
27207 PyThreadState* __tstate = wxPyBeginAllowThreads();
27208 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27209
27210 wxPyEndAllowThreads(__tstate);
27211 if (PyErr_Occurred()) SWIG_fail;
27212 }
27213 resultobj = result;
27214 return resultobj;
27215 fail:
27216 return NULL;
27217 }
27218
27219
27220 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27221 PyObject *resultobj;
27222 wxDataObject *arg1 = (wxDataObject *) 0 ;
27223 wxDataFormat *arg2 = 0 ;
27224 PyObject *result;
27225 PyObject * obj0 = 0 ;
27226 PyObject * obj1 = 0 ;
27227 char *kwnames[] = {
27228 (char *) "self",(char *) "format", NULL
27229 };
27230
27231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27233 if (SWIG_arg_fail(1)) SWIG_fail;
27234 {
27235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27236 if (SWIG_arg_fail(2)) SWIG_fail;
27237 if (arg2 == NULL) {
27238 SWIG_null_ref("wxDataFormat");
27239 }
27240 if (SWIG_arg_fail(2)) SWIG_fail;
27241 }
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*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_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27257 PyObject *resultobj;
27258 wxDataObject *arg1 = (wxDataObject *) 0 ;
27259 wxDataFormat *arg2 = 0 ;
27260 PyObject *arg3 = (PyObject *) 0 ;
27261 bool result;
27262 PyObject * obj0 = 0 ;
27263 PyObject * obj1 = 0 ;
27264 PyObject * obj2 = 0 ;
27265 char *kwnames[] = {
27266 (char *) "self",(char *) "format",(char *) "data", NULL
27267 };
27268
27269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27271 if (SWIG_arg_fail(1)) SWIG_fail;
27272 {
27273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27274 if (SWIG_arg_fail(2)) SWIG_fail;
27275 if (arg2 == NULL) {
27276 SWIG_null_ref("wxDataFormat");
27277 }
27278 if (SWIG_arg_fail(2)) SWIG_fail;
27279 }
27280 arg3 = obj2;
27281 {
27282 PyThreadState* __tstate = wxPyBeginAllowThreads();
27283 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27284
27285 wxPyEndAllowThreads(__tstate);
27286 if (PyErr_Occurred()) SWIG_fail;
27287 }
27288 {
27289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27290 }
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27298 PyObject *obj;
27299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27300 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27301 Py_INCREF(obj);
27302 return Py_BuildValue((char *)"");
27303 }
27304 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27305 PyObject *resultobj;
27306 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27307 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27308 wxDataObjectSimple *result;
27309 PyObject * obj0 = 0 ;
27310 char *kwnames[] = {
27311 (char *) "format", NULL
27312 };
27313
27314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27315 if (obj0) {
27316 {
27317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27318 if (SWIG_arg_fail(1)) SWIG_fail;
27319 if (arg1 == NULL) {
27320 SWIG_null_ref("wxDataFormat");
27321 }
27322 if (SWIG_arg_fail(1)) SWIG_fail;
27323 }
27324 }
27325 {
27326 PyThreadState* __tstate = wxPyBeginAllowThreads();
27327 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27328
27329 wxPyEndAllowThreads(__tstate);
27330 if (PyErr_Occurred()) SWIG_fail;
27331 }
27332 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27333 return resultobj;
27334 fail:
27335 return NULL;
27336 }
27337
27338
27339 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27340 PyObject *resultobj;
27341 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27342 wxDataFormat *result;
27343 PyObject * obj0 = 0 ;
27344 char *kwnames[] = {
27345 (char *) "self", NULL
27346 };
27347
27348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27350 if (SWIG_arg_fail(1)) SWIG_fail;
27351 {
27352 PyThreadState* __tstate = wxPyBeginAllowThreads();
27353 {
27354 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27355 result = (wxDataFormat *) &_result_ref;
27356 }
27357
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27362 return resultobj;
27363 fail:
27364 return NULL;
27365 }
27366
27367
27368 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27369 PyObject *resultobj;
27370 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27371 wxDataFormat *arg2 = 0 ;
27372 PyObject * obj0 = 0 ;
27373 PyObject * obj1 = 0 ;
27374 char *kwnames[] = {
27375 (char *) "self",(char *) "format", NULL
27376 };
27377
27378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27380 if (SWIG_arg_fail(1)) SWIG_fail;
27381 {
27382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27383 if (SWIG_arg_fail(2)) SWIG_fail;
27384 if (arg2 == NULL) {
27385 SWIG_null_ref("wxDataFormat");
27386 }
27387 if (SWIG_arg_fail(2)) SWIG_fail;
27388 }
27389 {
27390 PyThreadState* __tstate = wxPyBeginAllowThreads();
27391 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27392
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 Py_INCREF(Py_None); resultobj = Py_None;
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27404 PyObject *resultobj;
27405 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27406 size_t result;
27407 PyObject * obj0 = 0 ;
27408 char *kwnames[] = {
27409 (char *) "self", NULL
27410 };
27411
27412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27414 if (SWIG_arg_fail(1)) SWIG_fail;
27415 {
27416 PyThreadState* __tstate = wxPyBeginAllowThreads();
27417 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27418
27419 wxPyEndAllowThreads(__tstate);
27420 if (PyErr_Occurred()) SWIG_fail;
27421 }
27422 {
27423 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27424 }
27425 return resultobj;
27426 fail:
27427 return NULL;
27428 }
27429
27430
27431 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27432 PyObject *resultobj;
27433 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27434 PyObject *result;
27435 PyObject * obj0 = 0 ;
27436 char *kwnames[] = {
27437 (char *) "self", NULL
27438 };
27439
27440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27442 if (SWIG_arg_fail(1)) SWIG_fail;
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27446
27447 wxPyEndAllowThreads(__tstate);
27448 if (PyErr_Occurred()) SWIG_fail;
27449 }
27450 resultobj = result;
27451 return resultobj;
27452 fail:
27453 return NULL;
27454 }
27455
27456
27457 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27458 PyObject *resultobj;
27459 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27460 PyObject *arg2 = (PyObject *) 0 ;
27461 bool result;
27462 PyObject * obj0 = 0 ;
27463 PyObject * obj1 = 0 ;
27464 char *kwnames[] = {
27465 (char *) "self",(char *) "data", NULL
27466 };
27467
27468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27470 if (SWIG_arg_fail(1)) SWIG_fail;
27471 arg2 = obj1;
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27475
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 {
27480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27481 }
27482 return resultobj;
27483 fail:
27484 return NULL;
27485 }
27486
27487
27488 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27489 PyObject *obj;
27490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27491 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27492 Py_INCREF(obj);
27493 return Py_BuildValue((char *)"");
27494 }
27495 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj;
27497 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27498 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27499 wxPyDataObjectSimple *result;
27500 PyObject * obj0 = 0 ;
27501 char *kwnames[] = {
27502 (char *) "format", NULL
27503 };
27504
27505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27506 if (obj0) {
27507 {
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 if (arg1 == NULL) {
27511 SWIG_null_ref("wxDataFormat");
27512 }
27513 if (SWIG_arg_fail(1)) SWIG_fail;
27514 }
27515 }
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27531 PyObject *resultobj;
27532 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27533 PyObject *arg2 = (PyObject *) 0 ;
27534 PyObject *arg3 = (PyObject *) 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 PyObject * obj2 = 0 ;
27538 char *kwnames[] = {
27539 (char *) "self",(char *) "self",(char *) "_class", NULL
27540 };
27541
27542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27544 if (SWIG_arg_fail(1)) SWIG_fail;
27545 arg2 = obj1;
27546 arg3 = obj2;
27547 {
27548 PyThreadState* __tstate = wxPyBeginAllowThreads();
27549 (arg1)->_setCallbackInfo(arg2,arg3);
27550
27551 wxPyEndAllowThreads(__tstate);
27552 if (PyErr_Occurred()) SWIG_fail;
27553 }
27554 Py_INCREF(Py_None); resultobj = Py_None;
27555 return resultobj;
27556 fail:
27557 return NULL;
27558 }
27559
27560
27561 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27562 PyObject *obj;
27563 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27564 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27565 Py_INCREF(obj);
27566 return Py_BuildValue((char *)"");
27567 }
27568 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27569 PyObject *resultobj;
27570 wxDataObjectComposite *result;
27571 char *kwnames[] = {
27572 NULL
27573 };
27574
27575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27576 {
27577 PyThreadState* __tstate = wxPyBeginAllowThreads();
27578 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27579
27580 wxPyEndAllowThreads(__tstate);
27581 if (PyErr_Occurred()) SWIG_fail;
27582 }
27583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27584 return resultobj;
27585 fail:
27586 return NULL;
27587 }
27588
27589
27590 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27591 PyObject *resultobj;
27592 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27593 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27594 bool arg3 = (bool) false ;
27595 PyObject * obj0 = 0 ;
27596 PyObject * obj1 = 0 ;
27597 PyObject * obj2 = 0 ;
27598 char *kwnames[] = {
27599 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27600 };
27601
27602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27604 if (SWIG_arg_fail(1)) SWIG_fail;
27605 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27606 if (SWIG_arg_fail(2)) SWIG_fail;
27607 if (obj2) {
27608 {
27609 arg3 = (bool)(SWIG_As_bool(obj2));
27610 if (SWIG_arg_fail(3)) SWIG_fail;
27611 }
27612 }
27613 {
27614 PyThreadState* __tstate = wxPyBeginAllowThreads();
27615 (arg1)->Add(arg2,arg3);
27616
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 Py_INCREF(Py_None); resultobj = Py_None;
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27628 PyObject *obj;
27629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27630 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27631 Py_INCREF(obj);
27632 return Py_BuildValue((char *)"");
27633 }
27634 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27635 PyObject *resultobj;
27636 wxString const &arg1_defvalue = wxPyEmptyString ;
27637 wxString *arg1 = (wxString *) &arg1_defvalue ;
27638 wxTextDataObject *result;
27639 bool temp1 = false ;
27640 PyObject * obj0 = 0 ;
27641 char *kwnames[] = {
27642 (char *) "text", NULL
27643 };
27644
27645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27646 if (obj0) {
27647 {
27648 arg1 = wxString_in_helper(obj0);
27649 if (arg1 == NULL) SWIG_fail;
27650 temp1 = true;
27651 }
27652 }
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27656
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27661 {
27662 if (temp1)
27663 delete arg1;
27664 }
27665 return resultobj;
27666 fail:
27667 {
27668 if (temp1)
27669 delete arg1;
27670 }
27671 return NULL;
27672 }
27673
27674
27675 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27676 PyObject *resultobj;
27677 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27678 size_t result;
27679 PyObject * obj0 = 0 ;
27680 char *kwnames[] = {
27681 (char *) "self", NULL
27682 };
27683
27684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27686 if (SWIG_arg_fail(1)) SWIG_fail;
27687 {
27688 PyThreadState* __tstate = wxPyBeginAllowThreads();
27689 result = (size_t)(arg1)->GetTextLength();
27690
27691 wxPyEndAllowThreads(__tstate);
27692 if (PyErr_Occurred()) SWIG_fail;
27693 }
27694 {
27695 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27696 }
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27704 PyObject *resultobj;
27705 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27706 wxString result;
27707 PyObject * obj0 = 0 ;
27708 char *kwnames[] = {
27709 (char *) "self", NULL
27710 };
27711
27712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27714 if (SWIG_arg_fail(1)) SWIG_fail;
27715 {
27716 PyThreadState* __tstate = wxPyBeginAllowThreads();
27717 result = (arg1)->GetText();
27718
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 {
27723 #if wxUSE_UNICODE
27724 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27725 #else
27726 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27727 #endif
27728 }
27729 return resultobj;
27730 fail:
27731 return NULL;
27732 }
27733
27734
27735 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27736 PyObject *resultobj;
27737 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27738 wxString *arg2 = 0 ;
27739 bool temp2 = false ;
27740 PyObject * obj0 = 0 ;
27741 PyObject * obj1 = 0 ;
27742 char *kwnames[] = {
27743 (char *) "self",(char *) "text", NULL
27744 };
27745
27746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27748 if (SWIG_arg_fail(1)) SWIG_fail;
27749 {
27750 arg2 = wxString_in_helper(obj1);
27751 if (arg2 == NULL) SWIG_fail;
27752 temp2 = true;
27753 }
27754 {
27755 PyThreadState* __tstate = wxPyBeginAllowThreads();
27756 (arg1)->SetText((wxString const &)*arg2);
27757
27758 wxPyEndAllowThreads(__tstate);
27759 if (PyErr_Occurred()) SWIG_fail;
27760 }
27761 Py_INCREF(Py_None); resultobj = Py_None;
27762 {
27763 if (temp2)
27764 delete arg2;
27765 }
27766 return resultobj;
27767 fail:
27768 {
27769 if (temp2)
27770 delete arg2;
27771 }
27772 return NULL;
27773 }
27774
27775
27776 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27777 PyObject *obj;
27778 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27779 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27780 Py_INCREF(obj);
27781 return Py_BuildValue((char *)"");
27782 }
27783 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27784 PyObject *resultobj;
27785 wxString const &arg1_defvalue = wxPyEmptyString ;
27786 wxString *arg1 = (wxString *) &arg1_defvalue ;
27787 wxPyTextDataObject *result;
27788 bool temp1 = false ;
27789 PyObject * obj0 = 0 ;
27790 char *kwnames[] = {
27791 (char *) "text", NULL
27792 };
27793
27794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27795 if (obj0) {
27796 {
27797 arg1 = wxString_in_helper(obj0);
27798 if (arg1 == NULL) SWIG_fail;
27799 temp1 = true;
27800 }
27801 }
27802 {
27803 PyThreadState* __tstate = wxPyBeginAllowThreads();
27804 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27805
27806 wxPyEndAllowThreads(__tstate);
27807 if (PyErr_Occurred()) SWIG_fail;
27808 }
27809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27810 {
27811 if (temp1)
27812 delete arg1;
27813 }
27814 return resultobj;
27815 fail:
27816 {
27817 if (temp1)
27818 delete arg1;
27819 }
27820 return NULL;
27821 }
27822
27823
27824 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27825 PyObject *resultobj;
27826 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27827 PyObject *arg2 = (PyObject *) 0 ;
27828 PyObject *arg3 = (PyObject *) 0 ;
27829 PyObject * obj0 = 0 ;
27830 PyObject * obj1 = 0 ;
27831 PyObject * obj2 = 0 ;
27832 char *kwnames[] = {
27833 (char *) "self",(char *) "self",(char *) "_class", NULL
27834 };
27835
27836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27838 if (SWIG_arg_fail(1)) SWIG_fail;
27839 arg2 = obj1;
27840 arg3 = obj2;
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 (arg1)->_setCallbackInfo(arg2,arg3);
27844
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 Py_INCREF(Py_None); resultobj = Py_None;
27849 return resultobj;
27850 fail:
27851 return NULL;
27852 }
27853
27854
27855 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27856 PyObject *obj;
27857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27858 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27859 Py_INCREF(obj);
27860 return Py_BuildValue((char *)"");
27861 }
27862 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj;
27864 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27865 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27866 wxBitmapDataObject *result;
27867 PyObject * obj0 = 0 ;
27868 char *kwnames[] = {
27869 (char *) "bitmap", NULL
27870 };
27871
27872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27873 if (obj0) {
27874 {
27875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27876 if (SWIG_arg_fail(1)) SWIG_fail;
27877 if (arg1 == NULL) {
27878 SWIG_null_ref("wxBitmap");
27879 }
27880 if (SWIG_arg_fail(1)) SWIG_fail;
27881 }
27882 }
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27886
27887 wxPyEndAllowThreads(__tstate);
27888 if (PyErr_Occurred()) SWIG_fail;
27889 }
27890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27891 return resultobj;
27892 fail:
27893 return NULL;
27894 }
27895
27896
27897 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27898 PyObject *resultobj;
27899 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27900 wxBitmap result;
27901 PyObject * obj0 = 0 ;
27902 char *kwnames[] = {
27903 (char *) "self", NULL
27904 };
27905
27906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27908 if (SWIG_arg_fail(1)) SWIG_fail;
27909 {
27910 PyThreadState* __tstate = wxPyBeginAllowThreads();
27911 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27912
27913 wxPyEndAllowThreads(__tstate);
27914 if (PyErr_Occurred()) SWIG_fail;
27915 }
27916 {
27917 wxBitmap * resultptr;
27918 resultptr = new wxBitmap((wxBitmap &)(result));
27919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27920 }
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27928 PyObject *resultobj;
27929 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27930 wxBitmap *arg2 = 0 ;
27931 PyObject * obj0 = 0 ;
27932 PyObject * obj1 = 0 ;
27933 char *kwnames[] = {
27934 (char *) "self",(char *) "bitmap", NULL
27935 };
27936
27937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27939 if (SWIG_arg_fail(1)) SWIG_fail;
27940 {
27941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27942 if (SWIG_arg_fail(2)) SWIG_fail;
27943 if (arg2 == NULL) {
27944 SWIG_null_ref("wxBitmap");
27945 }
27946 if (SWIG_arg_fail(2)) SWIG_fail;
27947 }
27948 {
27949 PyThreadState* __tstate = wxPyBeginAllowThreads();
27950 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27951
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 Py_INCREF(Py_None); resultobj = Py_None;
27956 return resultobj;
27957 fail:
27958 return NULL;
27959 }
27960
27961
27962 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27963 PyObject *obj;
27964 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27965 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27966 Py_INCREF(obj);
27967 return Py_BuildValue((char *)"");
27968 }
27969 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27970 PyObject *resultobj;
27971 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27972 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27973 wxPyBitmapDataObject *result;
27974 PyObject * obj0 = 0 ;
27975 char *kwnames[] = {
27976 (char *) "bitmap", NULL
27977 };
27978
27979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27980 if (obj0) {
27981 {
27982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27983 if (SWIG_arg_fail(1)) SWIG_fail;
27984 if (arg1 == NULL) {
27985 SWIG_null_ref("wxBitmap");
27986 }
27987 if (SWIG_arg_fail(1)) SWIG_fail;
27988 }
27989 }
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27993
27994 wxPyEndAllowThreads(__tstate);
27995 if (PyErr_Occurred()) SWIG_fail;
27996 }
27997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj;
28006 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
28007 PyObject *arg2 = (PyObject *) 0 ;
28008 PyObject *arg3 = (PyObject *) 0 ;
28009 PyObject * obj0 = 0 ;
28010 PyObject * obj1 = 0 ;
28011 PyObject * obj2 = 0 ;
28012 char *kwnames[] = {
28013 (char *) "self",(char *) "self",(char *) "_class", NULL
28014 };
28015
28016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(1)) SWIG_fail;
28019 arg2 = obj1;
28020 arg3 = obj2;
28021 {
28022 PyThreadState* __tstate = wxPyBeginAllowThreads();
28023 (arg1)->_setCallbackInfo(arg2,arg3);
28024
28025 wxPyEndAllowThreads(__tstate);
28026 if (PyErr_Occurred()) SWIG_fail;
28027 }
28028 Py_INCREF(Py_None); resultobj = Py_None;
28029 return resultobj;
28030 fail:
28031 return NULL;
28032 }
28033
28034
28035 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
28036 PyObject *obj;
28037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28038 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
28039 Py_INCREF(obj);
28040 return Py_BuildValue((char *)"");
28041 }
28042 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28043 PyObject *resultobj;
28044 wxFileDataObject *result;
28045 char *kwnames[] = {
28046 NULL
28047 };
28048
28049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
28050 {
28051 PyThreadState* __tstate = wxPyBeginAllowThreads();
28052 result = (wxFileDataObject *)new wxFileDataObject();
28053
28054 wxPyEndAllowThreads(__tstate);
28055 if (PyErr_Occurred()) SWIG_fail;
28056 }
28057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28058 return resultobj;
28059 fail:
28060 return NULL;
28061 }
28062
28063
28064 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj;
28066 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28067 wxArrayString *result;
28068 PyObject * obj0 = 0 ;
28069 char *kwnames[] = {
28070 (char *) "self", NULL
28071 };
28072
28073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28075 if (SWIG_arg_fail(1)) SWIG_fail;
28076 {
28077 PyThreadState* __tstate = wxPyBeginAllowThreads();
28078 {
28079 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28080 result = (wxArrayString *) &_result_ref;
28081 }
28082
28083 wxPyEndAllowThreads(__tstate);
28084 if (PyErr_Occurred()) SWIG_fail;
28085 }
28086 {
28087 resultobj = wxArrayString2PyList_helper(*result);
28088 }
28089 return resultobj;
28090 fail:
28091 return NULL;
28092 }
28093
28094
28095 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28096 PyObject *resultobj;
28097 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28098 wxString *arg2 = 0 ;
28099 bool temp2 = false ;
28100 PyObject * obj0 = 0 ;
28101 PyObject * obj1 = 0 ;
28102 char *kwnames[] = {
28103 (char *) "self",(char *) "filename", NULL
28104 };
28105
28106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28108 if (SWIG_arg_fail(1)) SWIG_fail;
28109 {
28110 arg2 = wxString_in_helper(obj1);
28111 if (arg2 == NULL) SWIG_fail;
28112 temp2 = true;
28113 }
28114 {
28115 PyThreadState* __tstate = wxPyBeginAllowThreads();
28116 (arg1)->AddFile((wxString const &)*arg2);
28117
28118 wxPyEndAllowThreads(__tstate);
28119 if (PyErr_Occurred()) SWIG_fail;
28120 }
28121 Py_INCREF(Py_None); resultobj = Py_None;
28122 {
28123 if (temp2)
28124 delete arg2;
28125 }
28126 return resultobj;
28127 fail:
28128 {
28129 if (temp2)
28130 delete arg2;
28131 }
28132 return NULL;
28133 }
28134
28135
28136 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28137 PyObject *obj;
28138 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28139 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28140 Py_INCREF(obj);
28141 return Py_BuildValue((char *)"");
28142 }
28143 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28144 PyObject *resultobj;
28145 wxDataFormat *arg1 = 0 ;
28146 wxCustomDataObject *result;
28147 PyObject * obj0 = 0 ;
28148
28149 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28150 {
28151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28152 if (SWIG_arg_fail(1)) SWIG_fail;
28153 if (arg1 == NULL) {
28154 SWIG_null_ref("wxDataFormat");
28155 }
28156 if (SWIG_arg_fail(1)) SWIG_fail;
28157 }
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28161
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28166 return resultobj;
28167 fail:
28168 return NULL;
28169 }
28170
28171
28172 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28173 PyObject *resultobj;
28174 wxString *arg1 = 0 ;
28175 wxCustomDataObject *result;
28176 bool temp1 = false ;
28177 PyObject * obj0 = 0 ;
28178
28179 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28180 {
28181 arg1 = wxString_in_helper(obj0);
28182 if (arg1 == NULL) SWIG_fail;
28183 temp1 = true;
28184 }
28185 {
28186 PyThreadState* __tstate = wxPyBeginAllowThreads();
28187 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28188
28189 wxPyEndAllowThreads(__tstate);
28190 if (PyErr_Occurred()) SWIG_fail;
28191 }
28192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28193 {
28194 if (temp1)
28195 delete arg1;
28196 }
28197 return resultobj;
28198 fail:
28199 {
28200 if (temp1)
28201 delete arg1;
28202 }
28203 return NULL;
28204 }
28205
28206
28207 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28208 PyObject *resultobj;
28209 wxCustomDataObject *result;
28210
28211 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28212 {
28213 PyThreadState* __tstate = wxPyBeginAllowThreads();
28214 result = (wxCustomDataObject *)new wxCustomDataObject();
28215
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28227 int argc;
28228 PyObject *argv[2];
28229 int ii;
28230
28231 argc = PyObject_Length(args);
28232 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28233 argv[ii] = PyTuple_GetItem(args,ii);
28234 }
28235 if (argc == 0) {
28236 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28237 }
28238 if (argc == 1) {
28239 int _v;
28240 {
28241 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28242 }
28243 if (_v) {
28244 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28245 }
28246 }
28247 if (argc == 1) {
28248 int _v;
28249 {
28250 void *ptr = 0;
28251 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28252 _v = 0;
28253 PyErr_Clear();
28254 } else {
28255 _v = (ptr != 0);
28256 }
28257 }
28258 if (_v) {
28259 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28260 }
28261 }
28262
28263 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28264 return NULL;
28265 }
28266
28267
28268 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28269 PyObject *resultobj;
28270 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28271 PyObject *arg2 = (PyObject *) 0 ;
28272 bool result;
28273 PyObject * obj0 = 0 ;
28274 PyObject * obj1 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self",(char *) "data", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 arg2 = obj1;
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28286
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 {
28291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28292 }
28293 return resultobj;
28294 fail:
28295 return NULL;
28296 }
28297
28298
28299 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28300 PyObject *resultobj;
28301 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28302 size_t result;
28303 PyObject * obj0 = 0 ;
28304 char *kwnames[] = {
28305 (char *) "self", NULL
28306 };
28307
28308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28310 if (SWIG_arg_fail(1)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (size_t)(arg1)->GetSize();
28314
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 {
28319 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28320 }
28321 return resultobj;
28322 fail:
28323 return NULL;
28324 }
28325
28326
28327 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28328 PyObject *resultobj;
28329 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28330 PyObject *result;
28331 PyObject * obj0 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = result;
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28354 PyObject *obj;
28355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28356 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28357 Py_INCREF(obj);
28358 return Py_BuildValue((char *)"");
28359 }
28360 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28361 PyObject *resultobj;
28362 wxURLDataObject *result;
28363 char *kwnames[] = {
28364 NULL
28365 };
28366
28367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = (wxURLDataObject *)new wxURLDataObject();
28371
28372 wxPyEndAllowThreads(__tstate);
28373 if (PyErr_Occurred()) SWIG_fail;
28374 }
28375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28385 wxString result;
28386 PyObject * obj0 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (arg1)->GetURL();
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 #if wxUSE_UNICODE
28403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28404 #else
28405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28406 #endif
28407 }
28408 return resultobj;
28409 fail:
28410 return NULL;
28411 }
28412
28413
28414 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28415 PyObject *resultobj;
28416 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28417 wxString *arg2 = 0 ;
28418 bool temp2 = false ;
28419 PyObject * obj0 = 0 ;
28420 PyObject * obj1 = 0 ;
28421 char *kwnames[] = {
28422 (char *) "self",(char *) "url", NULL
28423 };
28424
28425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28427 if (SWIG_arg_fail(1)) SWIG_fail;
28428 {
28429 arg2 = wxString_in_helper(obj1);
28430 if (arg2 == NULL) SWIG_fail;
28431 temp2 = true;
28432 }
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 (arg1)->SetURL((wxString const &)*arg2);
28436
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 Py_INCREF(Py_None); resultobj = Py_None;
28441 {
28442 if (temp2)
28443 delete arg2;
28444 }
28445 return resultobj;
28446 fail:
28447 {
28448 if (temp2)
28449 delete arg2;
28450 }
28451 return NULL;
28452 }
28453
28454
28455 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28456 PyObject *obj;
28457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28458 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28459 Py_INCREF(obj);
28460 return Py_BuildValue((char *)"");
28461 }
28462 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj;
28464 wxMetafileDataObject *result;
28465 char *kwnames[] = {
28466 NULL
28467 };
28468
28469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28485 PyObject *obj;
28486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28487 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28488 Py_INCREF(obj);
28489 return Py_BuildValue((char *)"");
28490 }
28491 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj;
28493 wxDragResult arg1 ;
28494 bool result;
28495 PyObject * obj0 = 0 ;
28496 char *kwnames[] = {
28497 (char *) "res", NULL
28498 };
28499
28500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28501 {
28502 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28503 if (SWIG_arg_fail(1)) SWIG_fail;
28504 }
28505 {
28506 PyThreadState* __tstate = wxPyBeginAllowThreads();
28507 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28508
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 {
28513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28514 }
28515 return resultobj;
28516 fail:
28517 return NULL;
28518 }
28519
28520
28521 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28522 PyObject *resultobj;
28523 wxWindow *arg1 = (wxWindow *) 0 ;
28524 wxIcon const &arg2_defvalue = wxNullIcon ;
28525 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28526 wxIcon const &arg3_defvalue = wxNullIcon ;
28527 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28528 wxIcon const &arg4_defvalue = wxNullIcon ;
28529 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28530 wxPyDropSource *result;
28531 PyObject * obj0 = 0 ;
28532 PyObject * obj1 = 0 ;
28533 PyObject * obj2 = 0 ;
28534 PyObject * obj3 = 0 ;
28535 char *kwnames[] = {
28536 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28537 };
28538
28539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28541 if (SWIG_arg_fail(1)) SWIG_fail;
28542 if (obj1) {
28543 {
28544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28545 if (SWIG_arg_fail(2)) SWIG_fail;
28546 if (arg2 == NULL) {
28547 SWIG_null_ref("wxIcon");
28548 }
28549 if (SWIG_arg_fail(2)) SWIG_fail;
28550 }
28551 }
28552 if (obj2) {
28553 {
28554 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28555 if (SWIG_arg_fail(3)) SWIG_fail;
28556 if (arg3 == NULL) {
28557 SWIG_null_ref("wxIcon");
28558 }
28559 if (SWIG_arg_fail(3)) SWIG_fail;
28560 }
28561 }
28562 if (obj3) {
28563 {
28564 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(4)) SWIG_fail;
28566 if (arg4 == NULL) {
28567 SWIG_null_ref("wxIcon");
28568 }
28569 if (SWIG_arg_fail(4)) SWIG_fail;
28570 }
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28589 PyObject *arg2 = (PyObject *) 0 ;
28590 PyObject *arg3 = (PyObject *) 0 ;
28591 int arg4 ;
28592 PyObject * obj0 = 0 ;
28593 PyObject * obj1 = 0 ;
28594 PyObject * obj2 = 0 ;
28595 PyObject * obj3 = 0 ;
28596 char *kwnames[] = {
28597 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28598 };
28599
28600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28602 if (SWIG_arg_fail(1)) SWIG_fail;
28603 arg2 = obj1;
28604 arg3 = obj2;
28605 {
28606 arg4 = (int)(SWIG_As_int(obj3));
28607 if (SWIG_arg_fail(4)) SWIG_fail;
28608 }
28609 {
28610 PyThreadState* __tstate = wxPyBeginAllowThreads();
28611 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28612
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 Py_INCREF(Py_None); resultobj = Py_None;
28617 return resultobj;
28618 fail:
28619 return NULL;
28620 }
28621
28622
28623 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28624 PyObject *resultobj;
28625 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28626 PyObject * obj0 = 0 ;
28627 char *kwnames[] = {
28628 (char *) "self", NULL
28629 };
28630
28631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28633 if (SWIG_arg_fail(1)) SWIG_fail;
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 delete arg1;
28637
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 Py_INCREF(Py_None); resultobj = Py_None;
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj;
28650 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28651 wxDataObject *arg2 = 0 ;
28652 PyObject * obj0 = 0 ;
28653 PyObject * obj1 = 0 ;
28654 char *kwnames[] = {
28655 (char *) "self",(char *) "data", NULL
28656 };
28657
28658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28660 if (SWIG_arg_fail(1)) SWIG_fail;
28661 {
28662 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28663 if (SWIG_arg_fail(2)) SWIG_fail;
28664 if (arg2 == NULL) {
28665 SWIG_null_ref("wxDataObject");
28666 }
28667 if (SWIG_arg_fail(2)) SWIG_fail;
28668 }
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 (arg1)->SetData(*arg2);
28672
28673 wxPyEndAllowThreads(__tstate);
28674 if (PyErr_Occurred()) SWIG_fail;
28675 }
28676 Py_INCREF(Py_None); resultobj = Py_None;
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28684 PyObject *resultobj;
28685 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28686 wxDataObject *result;
28687 PyObject * obj0 = 0 ;
28688 char *kwnames[] = {
28689 (char *) "self", NULL
28690 };
28691
28692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28694 if (SWIG_arg_fail(1)) SWIG_fail;
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 result = (wxDataObject *)(arg1)->GetDataObject();
28698
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28703 return resultobj;
28704 fail:
28705 return NULL;
28706 }
28707
28708
28709 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28710 PyObject *resultobj;
28711 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28712 wxDragResult arg2 ;
28713 wxCursor *arg3 = 0 ;
28714 PyObject * obj0 = 0 ;
28715 PyObject * obj1 = 0 ;
28716 PyObject * obj2 = 0 ;
28717 char *kwnames[] = {
28718 (char *) "self",(char *) "res",(char *) "cursor", NULL
28719 };
28720
28721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28723 if (SWIG_arg_fail(1)) SWIG_fail;
28724 {
28725 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28726 if (SWIG_arg_fail(2)) SWIG_fail;
28727 }
28728 {
28729 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28730 if (SWIG_arg_fail(3)) SWIG_fail;
28731 if (arg3 == NULL) {
28732 SWIG_null_ref("wxCursor");
28733 }
28734 if (SWIG_arg_fail(3)) SWIG_fail;
28735 }
28736 {
28737 PyThreadState* __tstate = wxPyBeginAllowThreads();
28738 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28739
28740 wxPyEndAllowThreads(__tstate);
28741 if (PyErr_Occurred()) SWIG_fail;
28742 }
28743 Py_INCREF(Py_None); resultobj = Py_None;
28744 return resultobj;
28745 fail:
28746 return NULL;
28747 }
28748
28749
28750 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28751 PyObject *resultobj;
28752 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28753 int arg2 = (int) wxDrag_CopyOnly ;
28754 wxDragResult result;
28755 PyObject * obj0 = 0 ;
28756 PyObject * obj1 = 0 ;
28757 char *kwnames[] = {
28758 (char *) "self",(char *) "flags", NULL
28759 };
28760
28761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28763 if (SWIG_arg_fail(1)) SWIG_fail;
28764 if (obj1) {
28765 {
28766 arg2 = (int)(SWIG_As_int(obj1));
28767 if (SWIG_arg_fail(2)) SWIG_fail;
28768 }
28769 }
28770 {
28771 PyThreadState* __tstate = wxPyBeginAllowThreads();
28772 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28773
28774 wxPyEndAllowThreads(__tstate);
28775 if (PyErr_Occurred()) SWIG_fail;
28776 }
28777 resultobj = SWIG_From_int((result));
28778 return resultobj;
28779 fail:
28780 return NULL;
28781 }
28782
28783
28784 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28785 PyObject *resultobj;
28786 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28787 wxDragResult arg2 ;
28788 bool result;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self",(char *) "effect", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 {
28799 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28800 if (SWIG_arg_fail(2)) SWIG_fail;
28801 }
28802 {
28803 PyThreadState* __tstate = wxPyBeginAllowThreads();
28804 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28805
28806 wxPyEndAllowThreads(__tstate);
28807 if (PyErr_Occurred()) SWIG_fail;
28808 }
28809 {
28810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28811 }
28812 return resultobj;
28813 fail:
28814 return NULL;
28815 }
28816
28817
28818 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28819 PyObject *obj;
28820 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28821 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28822 Py_INCREF(obj);
28823 return Py_BuildValue((char *)"");
28824 }
28825 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28826 PyObject *resultobj;
28827 wxDataObject *arg1 = (wxDataObject *) NULL ;
28828 wxPyDropTarget *result;
28829 PyObject * obj0 = 0 ;
28830 char *kwnames[] = {
28831 (char *) "dataObject", NULL
28832 };
28833
28834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28835 if (obj0) {
28836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28837 if (SWIG_arg_fail(1)) SWIG_fail;
28838 }
28839 {
28840 PyThreadState* __tstate = wxPyBeginAllowThreads();
28841 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28842
28843 wxPyEndAllowThreads(__tstate);
28844 if (PyErr_Occurred()) SWIG_fail;
28845 }
28846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28847 return resultobj;
28848 fail:
28849 return NULL;
28850 }
28851
28852
28853 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28854 PyObject *resultobj;
28855 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28856 PyObject *arg2 = (PyObject *) 0 ;
28857 PyObject *arg3 = (PyObject *) 0 ;
28858 PyObject * obj0 = 0 ;
28859 PyObject * obj1 = 0 ;
28860 PyObject * obj2 = 0 ;
28861 char *kwnames[] = {
28862 (char *) "self",(char *) "self",(char *) "_class", NULL
28863 };
28864
28865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28867 if (SWIG_arg_fail(1)) SWIG_fail;
28868 arg2 = obj1;
28869 arg3 = obj2;
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 (arg1)->_setCallbackInfo(arg2,arg3);
28873
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 Py_INCREF(Py_None); resultobj = Py_None;
28878 return resultobj;
28879 fail:
28880 return NULL;
28881 }
28882
28883
28884 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28885 PyObject *resultobj;
28886 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28887 PyObject * obj0 = 0 ;
28888 char *kwnames[] = {
28889 (char *) "self", NULL
28890 };
28891
28892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28894 if (SWIG_arg_fail(1)) SWIG_fail;
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 delete arg1;
28898
28899 wxPyEndAllowThreads(__tstate);
28900 if (PyErr_Occurred()) SWIG_fail;
28901 }
28902 Py_INCREF(Py_None); resultobj = Py_None;
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj;
28911 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28912 wxDataObject *result;
28913 PyObject * obj0 = 0 ;
28914 char *kwnames[] = {
28915 (char *) "self", NULL
28916 };
28917
28918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28920 if (SWIG_arg_fail(1)) SWIG_fail;
28921 {
28922 PyThreadState* __tstate = wxPyBeginAllowThreads();
28923 result = (wxDataObject *)(arg1)->GetDataObject();
28924
28925 wxPyEndAllowThreads(__tstate);
28926 if (PyErr_Occurred()) SWIG_fail;
28927 }
28928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28929 return resultobj;
28930 fail:
28931 return NULL;
28932 }
28933
28934
28935 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28936 PyObject *resultobj;
28937 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28938 wxDataObject *arg2 = (wxDataObject *) 0 ;
28939 PyObject * obj0 = 0 ;
28940 PyObject * obj1 = 0 ;
28941 char *kwnames[] = {
28942 (char *) "self",(char *) "dataObject", NULL
28943 };
28944
28945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28947 if (SWIG_arg_fail(1)) SWIG_fail;
28948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28949 if (SWIG_arg_fail(2)) SWIG_fail;
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 (arg1)->SetDataObject(arg2);
28953
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 Py_INCREF(Py_None); resultobj = Py_None;
28958 return resultobj;
28959 fail:
28960 return NULL;
28961 }
28962
28963
28964 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28965 PyObject *resultobj;
28966 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28967 int arg2 ;
28968 int arg3 ;
28969 wxDragResult arg4 ;
28970 wxDragResult result;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 PyObject * obj2 = 0 ;
28974 PyObject * obj3 = 0 ;
28975 char *kwnames[] = {
28976 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28977 };
28978
28979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28981 if (SWIG_arg_fail(1)) SWIG_fail;
28982 {
28983 arg2 = (int)(SWIG_As_int(obj1));
28984 if (SWIG_arg_fail(2)) SWIG_fail;
28985 }
28986 {
28987 arg3 = (int)(SWIG_As_int(obj2));
28988 if (SWIG_arg_fail(3)) SWIG_fail;
28989 }
28990 {
28991 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28992 if (SWIG_arg_fail(4)) SWIG_fail;
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28997
28998 wxPyEndAllowThreads(__tstate);
28999 if (PyErr_Occurred()) SWIG_fail;
29000 }
29001 resultobj = SWIG_From_int((result));
29002 return resultobj;
29003 fail:
29004 return NULL;
29005 }
29006
29007
29008 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29009 PyObject *resultobj;
29010 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29011 int arg2 ;
29012 int arg3 ;
29013 wxDragResult arg4 ;
29014 wxDragResult result;
29015 PyObject * obj0 = 0 ;
29016 PyObject * obj1 = 0 ;
29017 PyObject * obj2 = 0 ;
29018 PyObject * obj3 = 0 ;
29019 char *kwnames[] = {
29020 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29021 };
29022
29023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29025 if (SWIG_arg_fail(1)) SWIG_fail;
29026 {
29027 arg2 = (int)(SWIG_As_int(obj1));
29028 if (SWIG_arg_fail(2)) SWIG_fail;
29029 }
29030 {
29031 arg3 = (int)(SWIG_As_int(obj2));
29032 if (SWIG_arg_fail(3)) SWIG_fail;
29033 }
29034 {
29035 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29036 if (SWIG_arg_fail(4)) SWIG_fail;
29037 }
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29041
29042 wxPyEndAllowThreads(__tstate);
29043 if (PyErr_Occurred()) SWIG_fail;
29044 }
29045 resultobj = SWIG_From_int((result));
29046 return resultobj;
29047 fail:
29048 return NULL;
29049 }
29050
29051
29052 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29053 PyObject *resultobj;
29054 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29055 PyObject * obj0 = 0 ;
29056 char *kwnames[] = {
29057 (char *) "self", NULL
29058 };
29059
29060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29062 if (SWIG_arg_fail(1)) SWIG_fail;
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 (arg1)->base_OnLeave();
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 Py_INCREF(Py_None); resultobj = Py_None;
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj;
29079 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29080 int arg2 ;
29081 int arg3 ;
29082 bool result;
29083 PyObject * obj0 = 0 ;
29084 PyObject * obj1 = 0 ;
29085 PyObject * obj2 = 0 ;
29086 char *kwnames[] = {
29087 (char *) "self",(char *) "x",(char *) "y", NULL
29088 };
29089
29090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29092 if (SWIG_arg_fail(1)) SWIG_fail;
29093 {
29094 arg2 = (int)(SWIG_As_int(obj1));
29095 if (SWIG_arg_fail(2)) SWIG_fail;
29096 }
29097 {
29098 arg3 = (int)(SWIG_As_int(obj2));
29099 if (SWIG_arg_fail(3)) SWIG_fail;
29100 }
29101 {
29102 PyThreadState* __tstate = wxPyBeginAllowThreads();
29103 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29104
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 {
29109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29110 }
29111 return resultobj;
29112 fail:
29113 return NULL;
29114 }
29115
29116
29117 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29118 PyObject *resultobj;
29119 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29120 bool result;
29121 PyObject * obj0 = 0 ;
29122 char *kwnames[] = {
29123 (char *) "self", NULL
29124 };
29125
29126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
29131 result = (bool)(arg1)->GetData();
29132
29133 wxPyEndAllowThreads(__tstate);
29134 if (PyErr_Occurred()) SWIG_fail;
29135 }
29136 {
29137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29138 }
29139 return resultobj;
29140 fail:
29141 return NULL;
29142 }
29143
29144
29145 static PyObject *_wrap_DropTarget_SetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29146 PyObject *resultobj;
29147 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29148 wxDragResult arg2 ;
29149 PyObject * obj0 = 0 ;
29150 PyObject * obj1 = 0 ;
29151 char *kwnames[] = {
29152 (char *) "self",(char *) "action", NULL
29153 };
29154
29155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDefaultAction",kwnames,&obj0,&obj1)) goto fail;
29156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29157 if (SWIG_arg_fail(1)) SWIG_fail;
29158 {
29159 arg2 = (wxDragResult)(SWIG_As_int(obj1));
29160 if (SWIG_arg_fail(2)) SWIG_fail;
29161 }
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 (arg1)->SetDefaultAction((wxDragResult )arg2);
29165
29166 wxPyEndAllowThreads(__tstate);
29167 if (PyErr_Occurred()) SWIG_fail;
29168 }
29169 Py_INCREF(Py_None); resultobj = Py_None;
29170 return resultobj;
29171 fail:
29172 return NULL;
29173 }
29174
29175
29176 static PyObject *_wrap_DropTarget_GetDefaultAction(PyObject *, PyObject *args, PyObject *kwargs) {
29177 PyObject *resultobj;
29178 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29179 wxDragResult result;
29180 PyObject * obj0 = 0 ;
29181 char *kwnames[] = {
29182 (char *) "self", NULL
29183 };
29184
29185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDefaultAction",kwnames,&obj0)) goto fail;
29186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29187 if (SWIG_arg_fail(1)) SWIG_fail;
29188 {
29189 PyThreadState* __tstate = wxPyBeginAllowThreads();
29190 result = (wxDragResult)(arg1)->GetDefaultAction();
29191
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_From_int((result));
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29203 PyObject *obj;
29204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29205 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29206 Py_INCREF(obj);
29207 return Py_BuildValue((char *)"");
29208 }
29209 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29210 PyObject *resultobj;
29211 wxPyTextDropTarget *result;
29212 char *kwnames[] = {
29213 NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29220
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj;
29233 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29234 PyObject *arg2 = (PyObject *) 0 ;
29235 PyObject *arg3 = (PyObject *) 0 ;
29236 PyObject * obj0 = 0 ;
29237 PyObject * obj1 = 0 ;
29238 PyObject * obj2 = 0 ;
29239 char *kwnames[] = {
29240 (char *) "self",(char *) "self",(char *) "_class", NULL
29241 };
29242
29243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29245 if (SWIG_arg_fail(1)) SWIG_fail;
29246 arg2 = obj1;
29247 arg3 = obj2;
29248 {
29249 PyThreadState* __tstate = wxPyBeginAllowThreads();
29250 (arg1)->_setCallbackInfo(arg2,arg3);
29251
29252 wxPyEndAllowThreads(__tstate);
29253 if (PyErr_Occurred()) SWIG_fail;
29254 }
29255 Py_INCREF(Py_None); resultobj = Py_None;
29256 return resultobj;
29257 fail:
29258 return NULL;
29259 }
29260
29261
29262 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29263 PyObject *resultobj;
29264 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29265 int arg2 ;
29266 int arg3 ;
29267 wxDragResult arg4 ;
29268 wxDragResult result;
29269 PyObject * obj0 = 0 ;
29270 PyObject * obj1 = 0 ;
29271 PyObject * obj2 = 0 ;
29272 PyObject * obj3 = 0 ;
29273 char *kwnames[] = {
29274 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29275 };
29276
29277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29279 if (SWIG_arg_fail(1)) SWIG_fail;
29280 {
29281 arg2 = (int)(SWIG_As_int(obj1));
29282 if (SWIG_arg_fail(2)) SWIG_fail;
29283 }
29284 {
29285 arg3 = (int)(SWIG_As_int(obj2));
29286 if (SWIG_arg_fail(3)) SWIG_fail;
29287 }
29288 {
29289 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29290 if (SWIG_arg_fail(4)) SWIG_fail;
29291 }
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29295
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 resultobj = SWIG_From_int((result));
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj;
29308 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29309 int arg2 ;
29310 int arg3 ;
29311 wxDragResult arg4 ;
29312 wxDragResult result;
29313 PyObject * obj0 = 0 ;
29314 PyObject * obj1 = 0 ;
29315 PyObject * obj2 = 0 ;
29316 PyObject * obj3 = 0 ;
29317 char *kwnames[] = {
29318 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29319 };
29320
29321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(1)) SWIG_fail;
29324 {
29325 arg2 = (int)(SWIG_As_int(obj1));
29326 if (SWIG_arg_fail(2)) SWIG_fail;
29327 }
29328 {
29329 arg3 = (int)(SWIG_As_int(obj2));
29330 if (SWIG_arg_fail(3)) SWIG_fail;
29331 }
29332 {
29333 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29334 if (SWIG_arg_fail(4)) SWIG_fail;
29335 }
29336 {
29337 PyThreadState* __tstate = wxPyBeginAllowThreads();
29338 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29339
29340 wxPyEndAllowThreads(__tstate);
29341 if (PyErr_Occurred()) SWIG_fail;
29342 }
29343 resultobj = SWIG_From_int((result));
29344 return resultobj;
29345 fail:
29346 return NULL;
29347 }
29348
29349
29350 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29351 PyObject *resultobj;
29352 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29353 PyObject * obj0 = 0 ;
29354 char *kwnames[] = {
29355 (char *) "self", NULL
29356 };
29357
29358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29360 if (SWIG_arg_fail(1)) SWIG_fail;
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 (arg1)->base_OnLeave();
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 Py_INCREF(Py_None); resultobj = Py_None;
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj;
29377 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29378 int arg2 ;
29379 int arg3 ;
29380 bool result;
29381 PyObject * obj0 = 0 ;
29382 PyObject * obj1 = 0 ;
29383 PyObject * obj2 = 0 ;
29384 char *kwnames[] = {
29385 (char *) "self",(char *) "x",(char *) "y", NULL
29386 };
29387
29388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29390 if (SWIG_arg_fail(1)) SWIG_fail;
29391 {
29392 arg2 = (int)(SWIG_As_int(obj1));
29393 if (SWIG_arg_fail(2)) SWIG_fail;
29394 }
29395 {
29396 arg3 = (int)(SWIG_As_int(obj2));
29397 if (SWIG_arg_fail(3)) SWIG_fail;
29398 }
29399 {
29400 PyThreadState* __tstate = wxPyBeginAllowThreads();
29401 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29402
29403 wxPyEndAllowThreads(__tstate);
29404 if (PyErr_Occurred()) SWIG_fail;
29405 }
29406 {
29407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29408 }
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29416 PyObject *resultobj;
29417 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29418 int arg2 ;
29419 int arg3 ;
29420 wxDragResult arg4 ;
29421 wxDragResult result;
29422 PyObject * obj0 = 0 ;
29423 PyObject * obj1 = 0 ;
29424 PyObject * obj2 = 0 ;
29425 PyObject * obj3 = 0 ;
29426 char *kwnames[] = {
29427 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29428 };
29429
29430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29432 if (SWIG_arg_fail(1)) SWIG_fail;
29433 {
29434 arg2 = (int)(SWIG_As_int(obj1));
29435 if (SWIG_arg_fail(2)) SWIG_fail;
29436 }
29437 {
29438 arg3 = (int)(SWIG_As_int(obj2));
29439 if (SWIG_arg_fail(3)) SWIG_fail;
29440 }
29441 {
29442 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29443 if (SWIG_arg_fail(4)) SWIG_fail;
29444 }
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29448
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_From_int((result));
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29460 PyObject *obj;
29461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29462 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29463 Py_INCREF(obj);
29464 return Py_BuildValue((char *)"");
29465 }
29466 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29467 PyObject *resultobj;
29468 wxPyFileDropTarget *result;
29469 char *kwnames[] = {
29470 NULL
29471 };
29472
29473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29474 {
29475 PyThreadState* __tstate = wxPyBeginAllowThreads();
29476 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29477
29478 wxPyEndAllowThreads(__tstate);
29479 if (PyErr_Occurred()) SWIG_fail;
29480 }
29481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29482 return resultobj;
29483 fail:
29484 return NULL;
29485 }
29486
29487
29488 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29489 PyObject *resultobj;
29490 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29491 PyObject *arg2 = (PyObject *) 0 ;
29492 PyObject *arg3 = (PyObject *) 0 ;
29493 PyObject * obj0 = 0 ;
29494 PyObject * obj1 = 0 ;
29495 PyObject * obj2 = 0 ;
29496 char *kwnames[] = {
29497 (char *) "self",(char *) "self",(char *) "_class", NULL
29498 };
29499
29500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29502 if (SWIG_arg_fail(1)) SWIG_fail;
29503 arg2 = obj1;
29504 arg3 = obj2;
29505 {
29506 PyThreadState* __tstate = wxPyBeginAllowThreads();
29507 (arg1)->_setCallbackInfo(arg2,arg3);
29508
29509 wxPyEndAllowThreads(__tstate);
29510 if (PyErr_Occurred()) SWIG_fail;
29511 }
29512 Py_INCREF(Py_None); resultobj = Py_None;
29513 return resultobj;
29514 fail:
29515 return NULL;
29516 }
29517
29518
29519 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj;
29521 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29522 int arg2 ;
29523 int arg3 ;
29524 wxDragResult arg4 ;
29525 wxDragResult result;
29526 PyObject * obj0 = 0 ;
29527 PyObject * obj1 = 0 ;
29528 PyObject * obj2 = 0 ;
29529 PyObject * obj3 = 0 ;
29530 char *kwnames[] = {
29531 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29532 };
29533
29534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29536 if (SWIG_arg_fail(1)) SWIG_fail;
29537 {
29538 arg2 = (int)(SWIG_As_int(obj1));
29539 if (SWIG_arg_fail(2)) SWIG_fail;
29540 }
29541 {
29542 arg3 = (int)(SWIG_As_int(obj2));
29543 if (SWIG_arg_fail(3)) SWIG_fail;
29544 }
29545 {
29546 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29547 if (SWIG_arg_fail(4)) SWIG_fail;
29548 }
29549 {
29550 PyThreadState* __tstate = wxPyBeginAllowThreads();
29551 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29552
29553 wxPyEndAllowThreads(__tstate);
29554 if (PyErr_Occurred()) SWIG_fail;
29555 }
29556 resultobj = SWIG_From_int((result));
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29564 PyObject *resultobj;
29565 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29566 int arg2 ;
29567 int arg3 ;
29568 wxDragResult arg4 ;
29569 wxDragResult result;
29570 PyObject * obj0 = 0 ;
29571 PyObject * obj1 = 0 ;
29572 PyObject * obj2 = 0 ;
29573 PyObject * obj3 = 0 ;
29574 char *kwnames[] = {
29575 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29576 };
29577
29578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29580 if (SWIG_arg_fail(1)) SWIG_fail;
29581 {
29582 arg2 = (int)(SWIG_As_int(obj1));
29583 if (SWIG_arg_fail(2)) SWIG_fail;
29584 }
29585 {
29586 arg3 = (int)(SWIG_As_int(obj2));
29587 if (SWIG_arg_fail(3)) SWIG_fail;
29588 }
29589 {
29590 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29591 if (SWIG_arg_fail(4)) SWIG_fail;
29592 }
29593 {
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29596
29597 wxPyEndAllowThreads(__tstate);
29598 if (PyErr_Occurred()) SWIG_fail;
29599 }
29600 resultobj = SWIG_From_int((result));
29601 return resultobj;
29602 fail:
29603 return NULL;
29604 }
29605
29606
29607 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29608 PyObject *resultobj;
29609 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29610 PyObject * obj0 = 0 ;
29611 char *kwnames[] = {
29612 (char *) "self", NULL
29613 };
29614
29615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29617 if (SWIG_arg_fail(1)) SWIG_fail;
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 (arg1)->base_OnLeave();
29621
29622 wxPyEndAllowThreads(__tstate);
29623 if (PyErr_Occurred()) SWIG_fail;
29624 }
29625 Py_INCREF(Py_None); resultobj = Py_None;
29626 return resultobj;
29627 fail:
29628 return NULL;
29629 }
29630
29631
29632 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29633 PyObject *resultobj;
29634 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29635 int arg2 ;
29636 int arg3 ;
29637 bool result;
29638 PyObject * obj0 = 0 ;
29639 PyObject * obj1 = 0 ;
29640 PyObject * obj2 = 0 ;
29641 char *kwnames[] = {
29642 (char *) "self",(char *) "x",(char *) "y", NULL
29643 };
29644
29645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29647 if (SWIG_arg_fail(1)) SWIG_fail;
29648 {
29649 arg2 = (int)(SWIG_As_int(obj1));
29650 if (SWIG_arg_fail(2)) SWIG_fail;
29651 }
29652 {
29653 arg3 = (int)(SWIG_As_int(obj2));
29654 if (SWIG_arg_fail(3)) SWIG_fail;
29655 }
29656 {
29657 PyThreadState* __tstate = wxPyBeginAllowThreads();
29658 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29659
29660 wxPyEndAllowThreads(__tstate);
29661 if (PyErr_Occurred()) SWIG_fail;
29662 }
29663 {
29664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29665 }
29666 return resultobj;
29667 fail:
29668 return NULL;
29669 }
29670
29671
29672 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29673 PyObject *resultobj;
29674 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29675 int arg2 ;
29676 int arg3 ;
29677 wxDragResult arg4 ;
29678 wxDragResult result;
29679 PyObject * obj0 = 0 ;
29680 PyObject * obj1 = 0 ;
29681 PyObject * obj2 = 0 ;
29682 PyObject * obj3 = 0 ;
29683 char *kwnames[] = {
29684 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29685 };
29686
29687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29689 if (SWIG_arg_fail(1)) SWIG_fail;
29690 {
29691 arg2 = (int)(SWIG_As_int(obj1));
29692 if (SWIG_arg_fail(2)) SWIG_fail;
29693 }
29694 {
29695 arg3 = (int)(SWIG_As_int(obj2));
29696 if (SWIG_arg_fail(3)) SWIG_fail;
29697 }
29698 {
29699 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29700 if (SWIG_arg_fail(4)) SWIG_fail;
29701 }
29702 {
29703 PyThreadState* __tstate = wxPyBeginAllowThreads();
29704 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29705
29706 wxPyEndAllowThreads(__tstate);
29707 if (PyErr_Occurred()) SWIG_fail;
29708 }
29709 resultobj = SWIG_From_int((result));
29710 return resultobj;
29711 fail:
29712 return NULL;
29713 }
29714
29715
29716 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29717 PyObject *obj;
29718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29719 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29720 Py_INCREF(obj);
29721 return Py_BuildValue((char *)"");
29722 }
29723 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29724 PyObject *resultobj;
29725 wxClipboard *result;
29726 char *kwnames[] = {
29727 NULL
29728 };
29729
29730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 result = (wxClipboard *)new wxClipboard();
29734
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj;
29747 wxClipboard *arg1 = (wxClipboard *) 0 ;
29748 PyObject * obj0 = 0 ;
29749 char *kwnames[] = {
29750 (char *) "self", NULL
29751 };
29752
29753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29755 if (SWIG_arg_fail(1)) SWIG_fail;
29756 {
29757 PyThreadState* __tstate = wxPyBeginAllowThreads();
29758 delete arg1;
29759
29760 wxPyEndAllowThreads(__tstate);
29761 if (PyErr_Occurred()) SWIG_fail;
29762 }
29763 Py_INCREF(Py_None); resultobj = Py_None;
29764 return resultobj;
29765 fail:
29766 return NULL;
29767 }
29768
29769
29770 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29771 PyObject *resultobj;
29772 wxClipboard *arg1 = (wxClipboard *) 0 ;
29773 bool result;
29774 PyObject * obj0 = 0 ;
29775 char *kwnames[] = {
29776 (char *) "self", NULL
29777 };
29778
29779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29781 if (SWIG_arg_fail(1)) SWIG_fail;
29782 {
29783 PyThreadState* __tstate = wxPyBeginAllowThreads();
29784 result = (bool)(arg1)->Open();
29785
29786 wxPyEndAllowThreads(__tstate);
29787 if (PyErr_Occurred()) SWIG_fail;
29788 }
29789 {
29790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29791 }
29792 return resultobj;
29793 fail:
29794 return NULL;
29795 }
29796
29797
29798 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29799 PyObject *resultobj;
29800 wxClipboard *arg1 = (wxClipboard *) 0 ;
29801 PyObject * obj0 = 0 ;
29802 char *kwnames[] = {
29803 (char *) "self", NULL
29804 };
29805
29806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29808 if (SWIG_arg_fail(1)) SWIG_fail;
29809 {
29810 PyThreadState* __tstate = wxPyBeginAllowThreads();
29811 (arg1)->Close();
29812
29813 wxPyEndAllowThreads(__tstate);
29814 if (PyErr_Occurred()) SWIG_fail;
29815 }
29816 Py_INCREF(Py_None); resultobj = Py_None;
29817 return resultobj;
29818 fail:
29819 return NULL;
29820 }
29821
29822
29823 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29824 PyObject *resultobj;
29825 wxClipboard *arg1 = (wxClipboard *) 0 ;
29826 bool result;
29827 PyObject * obj0 = 0 ;
29828 char *kwnames[] = {
29829 (char *) "self", NULL
29830 };
29831
29832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29834 if (SWIG_arg_fail(1)) SWIG_fail;
29835 {
29836 PyThreadState* __tstate = wxPyBeginAllowThreads();
29837 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29838
29839 wxPyEndAllowThreads(__tstate);
29840 if (PyErr_Occurred()) SWIG_fail;
29841 }
29842 {
29843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29844 }
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29852 PyObject *resultobj;
29853 wxClipboard *arg1 = (wxClipboard *) 0 ;
29854 wxDataObject *arg2 = (wxDataObject *) 0 ;
29855 bool result;
29856 PyObject * obj0 = 0 ;
29857 PyObject * obj1 = 0 ;
29858 char *kwnames[] = {
29859 (char *) "self",(char *) "data", NULL
29860 };
29861
29862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29864 if (SWIG_arg_fail(1)) SWIG_fail;
29865 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29866 if (SWIG_arg_fail(2)) SWIG_fail;
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 result = (bool)(arg1)->AddData(arg2);
29870
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29876 }
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29884 PyObject *resultobj;
29885 wxClipboard *arg1 = (wxClipboard *) 0 ;
29886 wxDataObject *arg2 = (wxDataObject *) 0 ;
29887 bool result;
29888 PyObject * obj0 = 0 ;
29889 PyObject * obj1 = 0 ;
29890 char *kwnames[] = {
29891 (char *) "self",(char *) "data", NULL
29892 };
29893
29894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29896 if (SWIG_arg_fail(1)) SWIG_fail;
29897 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29898 if (SWIG_arg_fail(2)) SWIG_fail;
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (bool)(arg1)->SetData(arg2);
29902
29903 wxPyEndAllowThreads(__tstate);
29904 if (PyErr_Occurred()) SWIG_fail;
29905 }
29906 {
29907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29908 }
29909 return resultobj;
29910 fail:
29911 return NULL;
29912 }
29913
29914
29915 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29916 PyObject *resultobj;
29917 wxClipboard *arg1 = (wxClipboard *) 0 ;
29918 wxDataFormat *arg2 = 0 ;
29919 bool result;
29920 PyObject * obj0 = 0 ;
29921 PyObject * obj1 = 0 ;
29922 char *kwnames[] = {
29923 (char *) "self",(char *) "format", NULL
29924 };
29925
29926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29928 if (SWIG_arg_fail(1)) SWIG_fail;
29929 {
29930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29931 if (SWIG_arg_fail(2)) SWIG_fail;
29932 if (arg2 == NULL) {
29933 SWIG_null_ref("wxDataFormat");
29934 }
29935 if (SWIG_arg_fail(2)) SWIG_fail;
29936 }
29937 {
29938 PyThreadState* __tstate = wxPyBeginAllowThreads();
29939 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29940
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 {
29945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29946 }
29947 return resultobj;
29948 fail:
29949 return NULL;
29950 }
29951
29952
29953 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29954 PyObject *resultobj;
29955 wxClipboard *arg1 = (wxClipboard *) 0 ;
29956 wxDataObject *arg2 = 0 ;
29957 bool result;
29958 PyObject * obj0 = 0 ;
29959 PyObject * obj1 = 0 ;
29960 char *kwnames[] = {
29961 (char *) "self",(char *) "data", NULL
29962 };
29963
29964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29966 if (SWIG_arg_fail(1)) SWIG_fail;
29967 {
29968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29969 if (SWIG_arg_fail(2)) SWIG_fail;
29970 if (arg2 == NULL) {
29971 SWIG_null_ref("wxDataObject");
29972 }
29973 if (SWIG_arg_fail(2)) SWIG_fail;
29974 }
29975 {
29976 PyThreadState* __tstate = wxPyBeginAllowThreads();
29977 result = (bool)(arg1)->GetData(*arg2);
29978
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 {
29983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29984 }
29985 return resultobj;
29986 fail:
29987 return NULL;
29988 }
29989
29990
29991 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj;
29993 wxClipboard *arg1 = (wxClipboard *) 0 ;
29994 PyObject * obj0 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
30000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(1)) SWIG_fail;
30002 {
30003 PyThreadState* __tstate = wxPyBeginAllowThreads();
30004 (arg1)->Clear();
30005
30006 wxPyEndAllowThreads(__tstate);
30007 if (PyErr_Occurred()) SWIG_fail;
30008 }
30009 Py_INCREF(Py_None); resultobj = Py_None;
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj;
30018 wxClipboard *arg1 = (wxClipboard *) 0 ;
30019 bool result;
30020 PyObject * obj0 = 0 ;
30021 char *kwnames[] = {
30022 (char *) "self", NULL
30023 };
30024
30025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
30026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30027 if (SWIG_arg_fail(1)) SWIG_fail;
30028 {
30029 PyThreadState* __tstate = wxPyBeginAllowThreads();
30030 result = (bool)(arg1)->Flush();
30031
30032 wxPyEndAllowThreads(__tstate);
30033 if (PyErr_Occurred()) SWIG_fail;
30034 }
30035 {
30036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30037 }
30038 return resultobj;
30039 fail:
30040 return NULL;
30041 }
30042
30043
30044 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
30045 PyObject *resultobj;
30046 wxClipboard *arg1 = (wxClipboard *) 0 ;
30047 bool arg2 = (bool) true ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 char *kwnames[] = {
30051 (char *) "self",(char *) "primary", NULL
30052 };
30053
30054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30056 if (SWIG_arg_fail(1)) SWIG_fail;
30057 if (obj1) {
30058 {
30059 arg2 = (bool)(SWIG_As_bool(obj1));
30060 if (SWIG_arg_fail(2)) SWIG_fail;
30061 }
30062 }
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 (arg1)->UsePrimarySelection(arg2);
30066
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 Py_INCREF(Py_None); resultobj = Py_None;
30071 return resultobj;
30072 fail:
30073 return NULL;
30074 }
30075
30076
30077 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30078 PyObject *resultobj;
30079 wxClipboard *result;
30080 char *kwnames[] = {
30081 NULL
30082 };
30083
30084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (wxClipboard *)wxClipboard::Get();
30088
30089 wxPyEndAllowThreads(__tstate);
30090 if (PyErr_Occurred()) SWIG_fail;
30091 }
30092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30093 return resultobj;
30094 fail:
30095 return NULL;
30096 }
30097
30098
30099 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30100 PyObject *obj;
30101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30102 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30103 Py_INCREF(obj);
30104 return Py_BuildValue((char *)"");
30105 }
30106 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30107 PyObject *resultobj;
30108 wxClipboard *arg1 = (wxClipboard *) NULL ;
30109 wxClipboardLocker *result;
30110 PyObject * obj0 = 0 ;
30111 char *kwnames[] = {
30112 (char *) "clipboard", NULL
30113 };
30114
30115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30116 if (obj0) {
30117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30118 if (SWIG_arg_fail(1)) SWIG_fail;
30119 }
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj;
30136 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30137 PyObject * obj0 = 0 ;
30138 char *kwnames[] = {
30139 (char *) "self", NULL
30140 };
30141
30142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30144 if (SWIG_arg_fail(1)) SWIG_fail;
30145 {
30146 PyThreadState* __tstate = wxPyBeginAllowThreads();
30147 delete arg1;
30148
30149 wxPyEndAllowThreads(__tstate);
30150 if (PyErr_Occurred()) SWIG_fail;
30151 }
30152 Py_INCREF(Py_None); resultobj = Py_None;
30153 return resultobj;
30154 fail:
30155 return NULL;
30156 }
30157
30158
30159 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30160 PyObject *resultobj;
30161 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30162 bool result;
30163 PyObject * obj0 = 0 ;
30164 char *kwnames[] = {
30165 (char *) "self", NULL
30166 };
30167
30168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30170 if (SWIG_arg_fail(1)) SWIG_fail;
30171 {
30172 PyThreadState* __tstate = wxPyBeginAllowThreads();
30173 result = (bool)wxClipboardLocker___nonzero__(arg1);
30174
30175 wxPyEndAllowThreads(__tstate);
30176 if (PyErr_Occurred()) SWIG_fail;
30177 }
30178 {
30179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30180 }
30181 return resultobj;
30182 fail:
30183 return NULL;
30184 }
30185
30186
30187 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30188 PyObject *obj;
30189 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30190 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30191 Py_INCREF(obj);
30192 return Py_BuildValue((char *)"");
30193 }
30194 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj;
30196 int arg1 = (int) 0 ;
30197 int arg2 = (int) 0 ;
30198 int arg3 = (int) 0 ;
30199 int arg4 = (int) 0 ;
30200 wxVideoMode *result;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 PyObject * obj2 = 0 ;
30204 PyObject * obj3 = 0 ;
30205 char *kwnames[] = {
30206 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30207 };
30208
30209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30210 if (obj0) {
30211 {
30212 arg1 = (int)(SWIG_As_int(obj0));
30213 if (SWIG_arg_fail(1)) SWIG_fail;
30214 }
30215 }
30216 if (obj1) {
30217 {
30218 arg2 = (int)(SWIG_As_int(obj1));
30219 if (SWIG_arg_fail(2)) SWIG_fail;
30220 }
30221 }
30222 if (obj2) {
30223 {
30224 arg3 = (int)(SWIG_As_int(obj2));
30225 if (SWIG_arg_fail(3)) SWIG_fail;
30226 }
30227 }
30228 if (obj3) {
30229 {
30230 arg4 = (int)(SWIG_As_int(obj3));
30231 if (SWIG_arg_fail(4)) SWIG_fail;
30232 }
30233 }
30234 {
30235 PyThreadState* __tstate = wxPyBeginAllowThreads();
30236 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30237
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30242 return resultobj;
30243 fail:
30244 return NULL;
30245 }
30246
30247
30248 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30249 PyObject *resultobj;
30250 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30251 PyObject * obj0 = 0 ;
30252 char *kwnames[] = {
30253 (char *) "self", NULL
30254 };
30255
30256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30258 if (SWIG_arg_fail(1)) SWIG_fail;
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 delete arg1;
30262
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 Py_INCREF(Py_None); resultobj = Py_None;
30267 return resultobj;
30268 fail:
30269 return NULL;
30270 }
30271
30272
30273 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30274 PyObject *resultobj;
30275 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30276 wxVideoMode *arg2 = 0 ;
30277 bool result;
30278 PyObject * obj0 = 0 ;
30279 PyObject * obj1 = 0 ;
30280 char *kwnames[] = {
30281 (char *) "self",(char *) "other", NULL
30282 };
30283
30284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30286 if (SWIG_arg_fail(1)) SWIG_fail;
30287 {
30288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30289 if (SWIG_arg_fail(2)) SWIG_fail;
30290 if (arg2 == NULL) {
30291 SWIG_null_ref("wxVideoMode");
30292 }
30293 if (SWIG_arg_fail(2)) SWIG_fail;
30294 }
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30298
30299 wxPyEndAllowThreads(__tstate);
30300 if (PyErr_Occurred()) SWIG_fail;
30301 }
30302 {
30303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30304 }
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj;
30313 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30314 int result;
30315 PyObject * obj0 = 0 ;
30316 char *kwnames[] = {
30317 (char *) "self", NULL
30318 };
30319
30320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30325 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30326
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 {
30331 resultobj = SWIG_From_int((int)(result));
30332 }
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj;
30341 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30342 int result;
30343 PyObject * obj0 = 0 ;
30344 char *kwnames[] = {
30345 (char *) "self", NULL
30346 };
30347
30348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30350 if (SWIG_arg_fail(1)) SWIG_fail;
30351 {
30352 PyThreadState* __tstate = wxPyBeginAllowThreads();
30353 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30354
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 resultobj = SWIG_From_int((int)(result));
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj;
30369 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30370 int result;
30371 PyObject * obj0 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30382
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 {
30387 resultobj = SWIG_From_int((int)(result));
30388 }
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj;
30397 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30398 bool result;
30399 PyObject * obj0 = 0 ;
30400 char *kwnames[] = {
30401 (char *) "self", NULL
30402 };
30403
30404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30406 if (SWIG_arg_fail(1)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 {
30415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30416 }
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30426 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30427 bool result;
30428 PyObject * obj0 = 0 ;
30429 PyObject * obj1 = 0 ;
30430 char *kwnames[] = {
30431 (char *) "self",(char *) "other", NULL
30432 };
30433
30434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30436 if (SWIG_arg_fail(1)) SWIG_fail;
30437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30438 if (SWIG_arg_fail(2)) SWIG_fail;
30439 {
30440 PyThreadState* __tstate = wxPyBeginAllowThreads();
30441 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30442
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 {
30447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30448 }
30449 return resultobj;
30450 fail:
30451 return NULL;
30452 }
30453
30454
30455 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30456 PyObject *resultobj;
30457 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30458 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30459 bool result;
30460 PyObject * obj0 = 0 ;
30461 PyObject * obj1 = 0 ;
30462 char *kwnames[] = {
30463 (char *) "self",(char *) "other", NULL
30464 };
30465
30466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30468 if (SWIG_arg_fail(1)) SWIG_fail;
30469 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(2)) SWIG_fail;
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30474
30475 wxPyEndAllowThreads(__tstate);
30476 if (PyErr_Occurred()) SWIG_fail;
30477 }
30478 {
30479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30480 }
30481 return resultobj;
30482 fail:
30483 return NULL;
30484 }
30485
30486
30487 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30488 PyObject *resultobj;
30489 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30490 int arg2 ;
30491 PyObject * obj0 = 0 ;
30492 PyObject * obj1 = 0 ;
30493 char *kwnames[] = {
30494 (char *) "self",(char *) "w", NULL
30495 };
30496
30497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30499 if (SWIG_arg_fail(1)) SWIG_fail;
30500 {
30501 arg2 = (int)(SWIG_As_int(obj1));
30502 if (SWIG_arg_fail(2)) SWIG_fail;
30503 }
30504 if (arg1) (arg1)->w = arg2;
30505
30506 Py_INCREF(Py_None); resultobj = Py_None;
30507 return resultobj;
30508 fail:
30509 return NULL;
30510 }
30511
30512
30513 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30514 PyObject *resultobj;
30515 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30516 int result;
30517 PyObject * obj0 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 result = (int) ((arg1)->w);
30526
30527 {
30528 resultobj = SWIG_From_int((int)(result));
30529 }
30530 return resultobj;
30531 fail:
30532 return NULL;
30533 }
30534
30535
30536 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30537 PyObject *resultobj;
30538 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30539 int arg2 ;
30540 PyObject * obj0 = 0 ;
30541 PyObject * obj1 = 0 ;
30542 char *kwnames[] = {
30543 (char *) "self",(char *) "h", NULL
30544 };
30545
30546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30548 if (SWIG_arg_fail(1)) SWIG_fail;
30549 {
30550 arg2 = (int)(SWIG_As_int(obj1));
30551 if (SWIG_arg_fail(2)) SWIG_fail;
30552 }
30553 if (arg1) (arg1)->h = arg2;
30554
30555 Py_INCREF(Py_None); resultobj = Py_None;
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj;
30564 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30565 int result;
30566 PyObject * obj0 = 0 ;
30567 char *kwnames[] = {
30568 (char *) "self", NULL
30569 };
30570
30571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30573 if (SWIG_arg_fail(1)) SWIG_fail;
30574 result = (int) ((arg1)->h);
30575
30576 {
30577 resultobj = SWIG_From_int((int)(result));
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj;
30587 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30588 int arg2 ;
30589 PyObject * obj0 = 0 ;
30590 PyObject * obj1 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self",(char *) "bpp", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 {
30599 arg2 = (int)(SWIG_As_int(obj1));
30600 if (SWIG_arg_fail(2)) SWIG_fail;
30601 }
30602 if (arg1) (arg1)->bpp = arg2;
30603
30604 Py_INCREF(Py_None); resultobj = Py_None;
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30612 PyObject *resultobj;
30613 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30614 int result;
30615 PyObject * obj0 = 0 ;
30616 char *kwnames[] = {
30617 (char *) "self", NULL
30618 };
30619
30620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30622 if (SWIG_arg_fail(1)) SWIG_fail;
30623 result = (int) ((arg1)->bpp);
30624
30625 {
30626 resultobj = SWIG_From_int((int)(result));
30627 }
30628 return resultobj;
30629 fail:
30630 return NULL;
30631 }
30632
30633
30634 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30635 PyObject *resultobj;
30636 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30637 int arg2 ;
30638 PyObject * obj0 = 0 ;
30639 PyObject * obj1 = 0 ;
30640 char *kwnames[] = {
30641 (char *) "self",(char *) "refresh", NULL
30642 };
30643
30644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30646 if (SWIG_arg_fail(1)) SWIG_fail;
30647 {
30648 arg2 = (int)(SWIG_As_int(obj1));
30649 if (SWIG_arg_fail(2)) SWIG_fail;
30650 }
30651 if (arg1) (arg1)->refresh = arg2;
30652
30653 Py_INCREF(Py_None); resultobj = Py_None;
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30663 int result;
30664 PyObject * obj0 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 result = (int) ((arg1)->refresh);
30673
30674 {
30675 resultobj = SWIG_From_int((int)(result));
30676 }
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30684 PyObject *obj;
30685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30686 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30687 Py_INCREF(obj);
30688 return Py_BuildValue((char *)"");
30689 }
30690 static int _wrap_DefaultVideoMode_set(PyObject *) {
30691 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30692 return 1;
30693 }
30694
30695
30696 static PyObject *_wrap_DefaultVideoMode_get(void) {
30697 PyObject *pyobj;
30698
30699 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30700 return pyobj;
30701 }
30702
30703
30704 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj;
30706 size_t arg1 = (size_t) 0 ;
30707 wxDisplay *result;
30708 PyObject * obj0 = 0 ;
30709 char *kwnames[] = {
30710 (char *) "index", NULL
30711 };
30712
30713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30714 if (obj0) {
30715 {
30716 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30717 if (SWIG_arg_fail(1)) SWIG_fail;
30718 }
30719 }
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (wxDisplay *)new wxDisplay(arg1);
30723
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30728 return resultobj;
30729 fail:
30730 return NULL;
30731 }
30732
30733
30734 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30735 PyObject *resultobj;
30736 wxDisplay *arg1 = (wxDisplay *) 0 ;
30737 PyObject * obj0 = 0 ;
30738 char *kwnames[] = {
30739 (char *) "self", NULL
30740 };
30741
30742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30744 if (SWIG_arg_fail(1)) SWIG_fail;
30745 {
30746 PyThreadState* __tstate = wxPyBeginAllowThreads();
30747 delete arg1;
30748
30749 wxPyEndAllowThreads(__tstate);
30750 if (PyErr_Occurred()) SWIG_fail;
30751 }
30752 Py_INCREF(Py_None); resultobj = Py_None;
30753 return resultobj;
30754 fail:
30755 return NULL;
30756 }
30757
30758
30759 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30760 PyObject *resultobj;
30761 size_t result;
30762 char *kwnames[] = {
30763 NULL
30764 };
30765
30766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30767 {
30768 PyThreadState* __tstate = wxPyBeginAllowThreads();
30769 result = (size_t)wxDisplay::GetCount();
30770
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30776 }
30777 return resultobj;
30778 fail:
30779 return NULL;
30780 }
30781
30782
30783 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30784 PyObject *resultobj;
30785 wxPoint *arg1 = 0 ;
30786 int result;
30787 wxPoint temp1 ;
30788 PyObject * obj0 = 0 ;
30789 char *kwnames[] = {
30790 (char *) "pt", NULL
30791 };
30792
30793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30794 {
30795 arg1 = &temp1;
30796 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30797 }
30798 {
30799 PyThreadState* __tstate = wxPyBeginAllowThreads();
30800 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30801
30802 wxPyEndAllowThreads(__tstate);
30803 if (PyErr_Occurred()) SWIG_fail;
30804 }
30805 {
30806 resultobj = SWIG_From_int((int)(result));
30807 }
30808 return resultobj;
30809 fail:
30810 return NULL;
30811 }
30812
30813
30814 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30815 PyObject *resultobj;
30816 wxWindow *arg1 = (wxWindow *) 0 ;
30817 int result;
30818 PyObject * obj0 = 0 ;
30819 char *kwnames[] = {
30820 (char *) "window", NULL
30821 };
30822
30823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30825 if (SWIG_arg_fail(1)) SWIG_fail;
30826 {
30827 PyThreadState* __tstate = wxPyBeginAllowThreads();
30828 result = (int)Display_GetFromWindow(arg1);
30829
30830 wxPyEndAllowThreads(__tstate);
30831 if (PyErr_Occurred()) SWIG_fail;
30832 }
30833 {
30834 resultobj = SWIG_From_int((int)(result));
30835 }
30836 return resultobj;
30837 fail:
30838 return NULL;
30839 }
30840
30841
30842 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30843 PyObject *resultobj;
30844 wxDisplay *arg1 = (wxDisplay *) 0 ;
30845 bool result;
30846 PyObject * obj0 = 0 ;
30847 char *kwnames[] = {
30848 (char *) "self", NULL
30849 };
30850
30851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30853 if (SWIG_arg_fail(1)) SWIG_fail;
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)((wxDisplay const *)arg1)->IsOk();
30857
30858 wxPyEndAllowThreads(__tstate);
30859 if (PyErr_Occurred()) SWIG_fail;
30860 }
30861 {
30862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30863 }
30864 return resultobj;
30865 fail:
30866 return NULL;
30867 }
30868
30869
30870 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30871 PyObject *resultobj;
30872 wxDisplay *arg1 = (wxDisplay *) 0 ;
30873 wxRect result;
30874 PyObject * obj0 = 0 ;
30875 char *kwnames[] = {
30876 (char *) "self", NULL
30877 };
30878
30879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30881 if (SWIG_arg_fail(1)) SWIG_fail;
30882 {
30883 PyThreadState* __tstate = wxPyBeginAllowThreads();
30884 result = ((wxDisplay const *)arg1)->GetGeometry();
30885
30886 wxPyEndAllowThreads(__tstate);
30887 if (PyErr_Occurred()) SWIG_fail;
30888 }
30889 {
30890 wxRect * resultptr;
30891 resultptr = new wxRect((wxRect &)(result));
30892 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30893 }
30894 return resultobj;
30895 fail:
30896 return NULL;
30897 }
30898
30899
30900 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30901 PyObject *resultobj;
30902 wxDisplay *arg1 = (wxDisplay *) 0 ;
30903 wxString result;
30904 PyObject * obj0 = 0 ;
30905 char *kwnames[] = {
30906 (char *) "self", NULL
30907 };
30908
30909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30911 if (SWIG_arg_fail(1)) SWIG_fail;
30912 {
30913 PyThreadState* __tstate = wxPyBeginAllowThreads();
30914 result = ((wxDisplay const *)arg1)->GetName();
30915
30916 wxPyEndAllowThreads(__tstate);
30917 if (PyErr_Occurred()) SWIG_fail;
30918 }
30919 {
30920 #if wxUSE_UNICODE
30921 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30922 #else
30923 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30924 #endif
30925 }
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj;
30934 wxDisplay *arg1 = (wxDisplay *) 0 ;
30935 bool result;
30936 PyObject * obj0 = 0 ;
30937 char *kwnames[] = {
30938 (char *) "self", NULL
30939 };
30940
30941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30943 if (SWIG_arg_fail(1)) SWIG_fail;
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30947
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 {
30952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30953 }
30954 return resultobj;
30955 fail:
30956 return NULL;
30957 }
30958
30959
30960 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30961 PyObject *resultobj;
30962 wxDisplay *arg1 = (wxDisplay *) 0 ;
30963 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30964 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30965 PyObject *result;
30966 PyObject * obj0 = 0 ;
30967 PyObject * obj1 = 0 ;
30968 char *kwnames[] = {
30969 (char *) "self",(char *) "mode", NULL
30970 };
30971
30972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30974 if (SWIG_arg_fail(1)) SWIG_fail;
30975 if (obj1) {
30976 {
30977 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(2)) SWIG_fail;
30979 if (arg2 == NULL) {
30980 SWIG_null_ref("wxVideoMode");
30981 }
30982 if (SWIG_arg_fail(2)) SWIG_fail;
30983 }
30984 }
30985 {
30986 PyThreadState* __tstate = wxPyBeginAllowThreads();
30987 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30988
30989 wxPyEndAllowThreads(__tstate);
30990 if (PyErr_Occurred()) SWIG_fail;
30991 }
30992 resultobj = result;
30993 return resultobj;
30994 fail:
30995 return NULL;
30996 }
30997
30998
30999 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
31000 PyObject *resultobj;
31001 wxDisplay *arg1 = (wxDisplay *) 0 ;
31002 wxVideoMode result;
31003 PyObject * obj0 = 0 ;
31004 char *kwnames[] = {
31005 (char *) "self", NULL
31006 };
31007
31008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) 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 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 result = ((wxDisplay const *)arg1)->GetCurrentMode();
31014
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 {
31019 wxVideoMode * resultptr;
31020 resultptr = new wxVideoMode((wxVideoMode &)(result));
31021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
31022 }
31023 return resultobj;
31024 fail:
31025 return NULL;
31026 }
31027
31028
31029 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
31030 PyObject *resultobj;
31031 wxDisplay *arg1 = (wxDisplay *) 0 ;
31032 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
31033 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
31034 bool result;
31035 PyObject * obj0 = 0 ;
31036 PyObject * obj1 = 0 ;
31037 char *kwnames[] = {
31038 (char *) "self",(char *) "mode", NULL
31039 };
31040
31041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
31042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31043 if (SWIG_arg_fail(1)) SWIG_fail;
31044 if (obj1) {
31045 {
31046 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
31047 if (SWIG_arg_fail(2)) SWIG_fail;
31048 if (arg2 == NULL) {
31049 SWIG_null_ref("wxVideoMode");
31050 }
31051 if (SWIG_arg_fail(2)) SWIG_fail;
31052 }
31053 }
31054 {
31055 PyThreadState* __tstate = wxPyBeginAllowThreads();
31056 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31057
31058 wxPyEndAllowThreads(__tstate);
31059 if (PyErr_Occurred()) SWIG_fail;
31060 }
31061 {
31062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31063 }
31064 return resultobj;
31065 fail:
31066 return NULL;
31067 }
31068
31069
31070 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31071 PyObject *resultobj;
31072 wxDisplay *arg1 = (wxDisplay *) 0 ;
31073 PyObject * obj0 = 0 ;
31074 char *kwnames[] = {
31075 (char *) "self", NULL
31076 };
31077
31078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31080 if (SWIG_arg_fail(1)) SWIG_fail;
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 (arg1)->ResetMode();
31084
31085 wxPyEndAllowThreads(__tstate);
31086 if (PyErr_Occurred()) SWIG_fail;
31087 }
31088 Py_INCREF(Py_None); resultobj = Py_None;
31089 return resultobj;
31090 fail:
31091 return NULL;
31092 }
31093
31094
31095 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31096 PyObject *obj;
31097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31098 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31099 Py_INCREF(obj);
31100 return Py_BuildValue((char *)"");
31101 }
31102 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31103 PyObject *resultobj;
31104 wxStandardPaths *result;
31105 char *kwnames[] = {
31106 NULL
31107 };
31108
31109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31110 {
31111 PyThreadState* __tstate = wxPyBeginAllowThreads();
31112 result = (wxStandardPaths *)StandardPaths_Get();
31113
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31118 return resultobj;
31119 fail:
31120 return NULL;
31121 }
31122
31123
31124 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31125 PyObject *resultobj;
31126 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31127 wxString result;
31128 PyObject * obj0 = 0 ;
31129 char *kwnames[] = {
31130 (char *) "self", NULL
31131 };
31132
31133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31135 if (SWIG_arg_fail(1)) SWIG_fail;
31136 {
31137 PyThreadState* __tstate = wxPyBeginAllowThreads();
31138 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31139
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 {
31144 #if wxUSE_UNICODE
31145 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31146 #else
31147 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31148 #endif
31149 }
31150 return resultobj;
31151 fail:
31152 return NULL;
31153 }
31154
31155
31156 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj;
31158 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31159 wxString result;
31160 PyObject * obj0 = 0 ;
31161 char *kwnames[] = {
31162 (char *) "self", NULL
31163 };
31164
31165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31167 if (SWIG_arg_fail(1)) SWIG_fail;
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31171
31172 wxPyEndAllowThreads(__tstate);
31173 if (PyErr_Occurred()) SWIG_fail;
31174 }
31175 {
31176 #if wxUSE_UNICODE
31177 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31178 #else
31179 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31180 #endif
31181 }
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31189 PyObject *resultobj;
31190 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31191 wxString result;
31192 PyObject * obj0 = 0 ;
31193 char *kwnames[] = {
31194 (char *) "self", NULL
31195 };
31196
31197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31199 if (SWIG_arg_fail(1)) SWIG_fail;
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31203
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 {
31208 #if wxUSE_UNICODE
31209 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31210 #else
31211 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31212 #endif
31213 }
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31221 PyObject *resultobj;
31222 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31223 wxString result;
31224 PyObject * obj0 = 0 ;
31225 char *kwnames[] = {
31226 (char *) "self", NULL
31227 };
31228
31229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31231 if (SWIG_arg_fail(1)) SWIG_fail;
31232 {
31233 PyThreadState* __tstate = wxPyBeginAllowThreads();
31234 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31235
31236 wxPyEndAllowThreads(__tstate);
31237 if (PyErr_Occurred()) SWIG_fail;
31238 }
31239 {
31240 #if wxUSE_UNICODE
31241 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31242 #else
31243 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31244 #endif
31245 }
31246 return resultobj;
31247 fail:
31248 return NULL;
31249 }
31250
31251
31252 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31253 PyObject *resultobj;
31254 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31255 wxString result;
31256 PyObject * obj0 = 0 ;
31257 char *kwnames[] = {
31258 (char *) "self", NULL
31259 };
31260
31261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31263 if (SWIG_arg_fail(1)) SWIG_fail;
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31267
31268 wxPyEndAllowThreads(__tstate);
31269 if (PyErr_Occurred()) SWIG_fail;
31270 }
31271 {
31272 #if wxUSE_UNICODE
31273 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31274 #else
31275 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31276 #endif
31277 }
31278 return resultobj;
31279 fail:
31280 return NULL;
31281 }
31282
31283
31284 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31285 PyObject *resultobj;
31286 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31287 wxString result;
31288 PyObject * obj0 = 0 ;
31289 char *kwnames[] = {
31290 (char *) "self", NULL
31291 };
31292
31293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31295 if (SWIG_arg_fail(1)) SWIG_fail;
31296 {
31297 PyThreadState* __tstate = wxPyBeginAllowThreads();
31298 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31299
31300 wxPyEndAllowThreads(__tstate);
31301 if (PyErr_Occurred()) SWIG_fail;
31302 }
31303 {
31304 #if wxUSE_UNICODE
31305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31306 #else
31307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31308 #endif
31309 }
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31317 PyObject *resultobj;
31318 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31319 wxString result;
31320 PyObject * obj0 = 0 ;
31321 char *kwnames[] = {
31322 (char *) "self", NULL
31323 };
31324
31325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31327 if (SWIG_arg_fail(1)) SWIG_fail;
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31331
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 {
31336 #if wxUSE_UNICODE
31337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31338 #else
31339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31340 #endif
31341 }
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31349 PyObject *resultobj;
31350 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31351 wxString *arg2 = 0 ;
31352 bool temp2 = false ;
31353 PyObject * obj0 = 0 ;
31354 PyObject * obj1 = 0 ;
31355 char *kwnames[] = {
31356 (char *) "self",(char *) "prefix", NULL
31357 };
31358
31359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31361 if (SWIG_arg_fail(1)) SWIG_fail;
31362 {
31363 arg2 = wxString_in_helper(obj1);
31364 if (arg2 == NULL) SWIG_fail;
31365 temp2 = true;
31366 }
31367 {
31368 PyThreadState* __tstate = wxPyBeginAllowThreads();
31369 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31370
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 Py_INCREF(Py_None); resultobj = Py_None;
31375 {
31376 if (temp2)
31377 delete arg2;
31378 }
31379 return resultobj;
31380 fail:
31381 {
31382 if (temp2)
31383 delete arg2;
31384 }
31385 return NULL;
31386 }
31387
31388
31389 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31390 PyObject *resultobj;
31391 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31392 wxString result;
31393 PyObject * obj0 = 0 ;
31394 char *kwnames[] = {
31395 (char *) "self", NULL
31396 };
31397
31398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31400 if (SWIG_arg_fail(1)) SWIG_fail;
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31404
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 {
31409 #if wxUSE_UNICODE
31410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31411 #else
31412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31413 #endif
31414 }
31415 return resultobj;
31416 fail:
31417 return NULL;
31418 }
31419
31420
31421 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31422 PyObject *obj;
31423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31424 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31425 Py_INCREF(obj);
31426 return Py_BuildValue((char *)"");
31427 }
31428 static PyMethodDef SwigMethods[] = {
31429 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31436 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"SystemOptions_IsFalse", (PyCFunction) _wrap_SystemOptions_IsFalse, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31444 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31508 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31516 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31534 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31537 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31540 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31543 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31549 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31563 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31569 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31575 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31578 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31592 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31595 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31596 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31599 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31626 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31628 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31630 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31632 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31639 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31645 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31659 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31663 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31666 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31683 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31691 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31738 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31756 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31766 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31782 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31798 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31812 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"ArtProvider_GetSizeHint", (PyCFunction) _wrap_ArtProvider_GetSizeHint, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31822 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31865 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31868 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31871 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31875 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31968 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31969 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31970 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31971 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31988 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
32033 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32067 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32075 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32076 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32081 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32090 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32097 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32100 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32103 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32108 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32111 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32115 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32118 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32122 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32123 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32127 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32131 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32133 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32143 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"DropTarget_SetDefaultAction", (PyCFunction) _wrap_DropTarget_SetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"DropTarget_GetDefaultAction", (PyCFunction) _wrap_DropTarget_GetDefaultAction, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32156 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32159 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32164 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32172 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32173 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32184 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32185 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32186 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32187 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32188 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32189 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32190 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32191 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32192 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32193 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32194 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32195 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32196 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32197 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32198 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32199 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32200 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32201 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32202 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32203 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32204 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32205 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32206 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32207 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32208 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32209 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32210 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32211 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32212 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32213 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32214 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32215 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32216 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32217 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32218 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32219 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32220 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32221 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32222 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32223 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32224 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32225 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32226 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32227 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32228 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32229 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32230 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32231 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32232 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32233 { NULL, NULL, 0, NULL }
32234 };
32235
32236
32237 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32238
32239 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32240 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32241 }
32242 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32243 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32244 }
32245 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32246 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32247 }
32248 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32249 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32250 }
32251 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32252 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32253 }
32254 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32255 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32256 }
32257 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32258 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32259 }
32260 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32261 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32262 }
32263 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32264 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32265 }
32266 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32267 return (void *)((wxEvent *) ((wxPyEvent *) x));
32268 }
32269 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32270 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32271 }
32272 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32273 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32274 }
32275 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32276 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32277 }
32278 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32279 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32280 }
32281 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32282 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32283 }
32284 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32285 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32286 }
32287 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32288 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32289 }
32290 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32291 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32292 }
32293 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32294 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32295 }
32296 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32297 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32298 }
32299 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32300 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32301 }
32302 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32303 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32304 }
32305 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32306 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32307 }
32308 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32310 }
32311 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32312 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32313 }
32314 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32315 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32316 }
32317 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32318 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32319 }
32320 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32321 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32322 }
32323 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32324 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32325 }
32326 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32327 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32328 }
32329 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32330 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32331 }
32332 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32333 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32334 }
32335 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32336 return (void *)((wxEvent *) ((wxShowEvent *) x));
32337 }
32338 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32339 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32340 }
32341 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32343 }
32344 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32345 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32346 }
32347 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32348 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32349 }
32350 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32351 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32352 }
32353 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32354 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32355 }
32356 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32357 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32358 }
32359 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32360 return (void *)((wxConfigBase *) ((wxConfig *) x));
32361 }
32362 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32363 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32364 }
32365 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32366 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32367 }
32368 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32369 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32370 }
32371 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32372 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32373 }
32374 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32375 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32376 }
32377 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32378 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32379 }
32380 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32381 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32382 }
32383 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32384 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32385 }
32386 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32387 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32388 }
32389 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32390 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32391 }
32392 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32393 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32394 }
32395 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32396 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32397 }
32398 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32399 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32400 }
32401 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32402 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32403 }
32404 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32405 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32406 }
32407 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32408 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32409 }
32410 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32411 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32412 }
32413 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32414 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32415 }
32416 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32417 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32418 }
32419 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32420 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32421 }
32422 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32423 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32424 }
32425 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32426 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32427 }
32428 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32429 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32430 }
32431 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32432 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32433 }
32434 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32435 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32436 }
32437 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32438 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32439 }
32440 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32441 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32442 }
32443 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32444 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32445 }
32446 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32447 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32448 }
32449 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32450 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32451 }
32452 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32453 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32454 }
32455 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32456 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32457 }
32458 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32459 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32460 }
32461 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32462 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32463 }
32464 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32465 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32466 }
32467 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32468 return (void *)((wxObject *) ((wxSizerItem *) x));
32469 }
32470 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32471 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32472 }
32473 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32474 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32475 }
32476 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32477 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32478 }
32479 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32480 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32481 }
32482 static void *_p_wxSizerTo_p_wxObject(void *x) {
32483 return (void *)((wxObject *) ((wxSizer *) x));
32484 }
32485 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32486 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32487 }
32488 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32489 return (void *)((wxObject *) ((wxFileHistory *) x));
32490 }
32491 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32492 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32493 }
32494 static void *_p_wxEventTo_p_wxObject(void *x) {
32495 return (void *)((wxObject *) ((wxEvent *) x));
32496 }
32497 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32498 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32499 }
32500 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32501 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32502 }
32503 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32504 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32505 }
32506 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32507 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32508 }
32509 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32510 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32511 }
32512 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32513 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32514 }
32515 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32516 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32517 }
32518 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32519 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32520 }
32521 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32522 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32523 }
32524 static void *_p_wxControlTo_p_wxObject(void *x) {
32525 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32526 }
32527 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32528 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32529 }
32530 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32531 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32532 }
32533 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32534 return (void *)((wxObject *) ((wxFSFile *) x));
32535 }
32536 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32537 return (void *)((wxObject *) ((wxClipboard *) x));
32538 }
32539 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32540 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32541 }
32542 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32543 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32544 }
32545 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32546 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32547 }
32548 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32549 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32550 }
32551 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32552 return (void *)((wxObject *) ((wxToolTip *) x));
32553 }
32554 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32555 return (void *)((wxObject *) ((wxMenuItem *) x));
32556 }
32557 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32559 }
32560 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32561 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32562 }
32563 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32565 }
32566 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32567 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32568 }
32569 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32570 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32571 }
32572 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32573 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32574 }
32575 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32576 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32577 }
32578 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32579 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32580 }
32581 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32582 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32583 }
32584 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32585 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32586 }
32587 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32588 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32589 }
32590 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32591 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32592 }
32593 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32594 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32595 }
32596 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32597 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32598 }
32599 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32600 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32601 }
32602 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32603 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32604 }
32605 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32606 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32607 }
32608 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32609 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32610 }
32611 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32612 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32613 }
32614 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32615 return (void *)((wxObject *) ((wxImageHandler *) x));
32616 }
32617 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32618 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32619 }
32620 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32621 return (void *)((wxObject *) ((wxEvtHandler *) x));
32622 }
32623 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32624 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32625 }
32626 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32627 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32628 }
32629 static void *_p_wxImageTo_p_wxObject(void *x) {
32630 return (void *)((wxObject *) ((wxImage *) x));
32631 }
32632 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32633 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32634 }
32635 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32636 return (void *)((wxObject *) ((wxSystemOptions *) x));
32637 }
32638 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32639 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32640 }
32641 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32643 }
32644 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32645 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32646 }
32647 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32648 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32649 }
32650 static void *_p_wxWindowTo_p_wxObject(void *x) {
32651 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32652 }
32653 static void *_p_wxMenuTo_p_wxObject(void *x) {
32654 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32655 }
32656 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32658 }
32659 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32660 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32661 }
32662 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32663 return (void *)((wxObject *) ((wxFileSystem *) x));
32664 }
32665 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32666 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32667 }
32668 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32669 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32670 }
32671 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32672 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32673 }
32674 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32675 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32676 }
32677 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32678 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32679 }
32680 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32681 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32682 }
32683 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32684 return (void *)((wxObject *) ((wxBusyInfo *) x));
32685 }
32686 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32687 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32688 }
32689 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32690 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32691 }
32692 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32693 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32694 }
32695 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32696 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32697 }
32698 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32699 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32700 }
32701 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32702 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32703 }
32704 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32705 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32706 }
32707 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32708 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32709 }
32710 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32711 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32712 }
32713 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32714 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32715 }
32716 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32717 return (void *)((wxLog *) ((wxLogStderr *) x));
32718 }
32719 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32720 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32721 }
32722 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32723 return (void *)((wxLog *) ((wxLogWindow *) x));
32724 }
32725 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32726 return (void *)((wxLog *) ((wxLogChain *) x));
32727 }
32728 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32729 return (void *)((wxLog *) ((wxLogGui *) x));
32730 }
32731 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32732 return (void *)((wxLog *) ((wxPyLog *) x));
32733 }
32734 static void *_p_wxControlTo_p_wxWindow(void *x) {
32735 return (void *)((wxWindow *) ((wxControl *) x));
32736 }
32737 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32738 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32739 }
32740 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32741 return (void *)((wxWindow *) ((wxMenuBar *) x));
32742 }
32743 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32744 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32745 }
32746 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32747 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32748 }
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767 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}};
32768 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}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797 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}};
32798 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}};
32799 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}};
32800 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}};
32801 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}};
32802 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}};
32803 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}};
32804 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}};
32805 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}};
32806 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}};
32807 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}};
32808 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}};
32809 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}};
32810 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}};
32811 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}};
32812 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}};
32813 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}};
32814 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}};
32815 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}};
32816 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}};
32817 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}};
32818 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}};
32819 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}};
32820 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}};
32821 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}};
32822 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}};
32823 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}};
32824 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}};
32825 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}};
32826 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}};
32827 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}};
32828 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}};
32829 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}};
32830 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}};
32831 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}};
32832 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}};
32833 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}};
32834 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}};
32835 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}};
32836 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}};
32837 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}};
32838 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}};
32839 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}};
32840 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}};
32841 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}};
32842 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}};
32843 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}};
32844 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}};
32845
32846 static swig_type_info *swig_types_initial[] = {
32847 _swigt__p_wxLogChain,
32848 _swigt__p_wxMutexGuiLocker,
32849 _swigt__p_wxFileHistory,
32850 _swigt__p_wxLog,
32851 _swigt__p_wxMenu,
32852 _swigt__p_wxEvent,
32853 _swigt__p_wxDateTime__TimeZone,
32854 _swigt__p_wxConfigBase,
32855 _swigt__p_wxDisplay,
32856 _swigt__p_wxFileType,
32857 _swigt__p_wxLogGui,
32858 _swigt__p_wxFont,
32859 _swigt__p_wxDataFormat,
32860 _swigt__p_wxTimerEvent,
32861 _swigt__p_wxCaret,
32862 _swigt__ptrdiff_t,
32863 _swigt__std__ptrdiff_t,
32864 _swigt__p_int,
32865 _swigt__p_wxSize,
32866 _swigt__p_wxClipboard,
32867 _swigt__p_wxStopWatch,
32868 _swigt__p_wxDC,
32869 _swigt__p_wxClipboardLocker,
32870 _swigt__p_wxIcon,
32871 _swigt__p_wxLogStderr,
32872 _swigt__p_wxLogTextCtrl,
32873 _swigt__p_wxTextCtrl,
32874 _swigt__p_wxBusyCursor,
32875 _swigt__p_wxBitmapDataObject,
32876 _swigt__p_wxTextDataObject,
32877 _swigt__p_wxDataObject,
32878 _swigt__p_wxPyTextDataObject,
32879 _swigt__p_wxPyBitmapDataObject,
32880 _swigt__p_wxFileDataObject,
32881 _swigt__p_wxCustomDataObject,
32882 _swigt__p_wxURLDataObject,
32883 _swigt__p_wxMetafileDataObject,
32884 _swigt__p_wxSound,
32885 _swigt__p_wxTimerRunner,
32886 _swigt__p_wxLogWindow,
32887 _swigt__p_wxTimeSpan,
32888 _swigt__p_wxArrayString,
32889 _swigt__p_wxWindowDisabler,
32890 _swigt__p_form_ops_t,
32891 _swigt__p_wxToolTip,
32892 _swigt__p_wxDataObjectComposite,
32893 _swigt__p_wxSystemSettings,
32894 _swigt__p_wxFileConfig,
32895 _swigt__p_wxVideoMode,
32896 _swigt__p_wxDataObjectSimple,
32897 _swigt__p_wxPyDataObjectSimple,
32898 _swigt__p_wxDuplexMode,
32899 _swigt__p_wxEvtHandler,
32900 _swigt__p_wxRect,
32901 _swigt__p_char,
32902 _swigt__p_wxSingleInstanceChecker,
32903 _swigt__p_wxStandardPaths,
32904 _swigt__p_wxFileTypeInfo,
32905 _swigt__p_wxFrame,
32906 _swigt__p_wxTimer,
32907 _swigt__p_wxPaperSize,
32908 _swigt__p_wxMimeTypesManager,
32909 _swigt__p_wxPyArtProvider,
32910 _swigt__p_wxPyTipProvider,
32911 _swigt__p_wxTipProvider,
32912 _swigt__p_wxJoystick,
32913 _swigt__p_wxSystemOptions,
32914 _swigt__p_wxPoint,
32915 _swigt__p_wxJoystickEvent,
32916 _swigt__p_wxCursor,
32917 _swigt__p_wxObject,
32918 _swigt__p_wxOutputStream,
32919 _swigt__p_wxDateTime,
32920 _swigt__p_wxPyDropSource,
32921 _swigt__p_unsigned_long,
32922 _swigt__p_wxKillError,
32923 _swigt__p_wxWindow,
32924 _swigt__p_wxString,
32925 _swigt__p_wxPyProcess,
32926 _swigt__p_wxBitmap,
32927 _swigt__p_wxConfig,
32928 _swigt__unsigned_int,
32929 _swigt__p_unsigned_int,
32930 _swigt__p_unsigned_char,
32931 _swigt__p_wxChar,
32932 _swigt__p_wxBusyInfo,
32933 _swigt__p_wxPyDropTarget,
32934 _swigt__p_wxPyTextDropTarget,
32935 _swigt__p_wxPyFileDropTarget,
32936 _swigt__p_wxProcessEvent,
32937 _swigt__p_wxPyLog,
32938 _swigt__p_wxLogNull,
32939 _swigt__p_wxColour,
32940 _swigt__p_wxPyTimer,
32941 _swigt__p_wxConfigPathChanger,
32942 _swigt__p_wxDateSpan,
32943 0
32944 };
32945
32946
32947 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32948
32949 static swig_const_info swig_const_table[] = {
32950 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32951 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32952 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32953 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32954 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32955 {0, 0, 0, 0.0, 0, 0}};
32956
32957 #ifdef __cplusplus
32958 }
32959 #endif
32960
32961
32962 #ifdef __cplusplus
32963 extern "C" {
32964 #endif
32965
32966 /* Python-specific SWIG API */
32967 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32968 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32969 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32970
32971 /* -----------------------------------------------------------------------------
32972 * global variable support code.
32973 * ----------------------------------------------------------------------------- */
32974
32975 typedef struct swig_globalvar {
32976 char *name; /* Name of global variable */
32977 PyObject *(*get_attr)(); /* Return the current value */
32978 int (*set_attr)(PyObject *); /* Set the value */
32979 struct swig_globalvar *next;
32980 } swig_globalvar;
32981
32982 typedef struct swig_varlinkobject {
32983 PyObject_HEAD
32984 swig_globalvar *vars;
32985 } swig_varlinkobject;
32986
32987 static PyObject *
32988 swig_varlink_repr(swig_varlinkobject *v) {
32989 v = v;
32990 return PyString_FromString("<Swig global variables>");
32991 }
32992
32993 static int
32994 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32995 swig_globalvar *var;
32996 flags = flags;
32997 fprintf(fp,"Swig global variables { ");
32998 for (var = v->vars; var; var=var->next) {
32999 fprintf(fp,"%s", var->name);
33000 if (var->next) fprintf(fp,", ");
33001 }
33002 fprintf(fp," }\n");
33003 return 0;
33004 }
33005
33006 static PyObject *
33007 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
33008 swig_globalvar *var = v->vars;
33009 while (var) {
33010 if (strcmp(var->name,n) == 0) {
33011 return (*var->get_attr)();
33012 }
33013 var = var->next;
33014 }
33015 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33016 return NULL;
33017 }
33018
33019 static int
33020 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
33021 swig_globalvar *var = v->vars;
33022 while (var) {
33023 if (strcmp(var->name,n) == 0) {
33024 return (*var->set_attr)(p);
33025 }
33026 var = var->next;
33027 }
33028 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
33029 return 1;
33030 }
33031
33032 static PyTypeObject varlinktype = {
33033 PyObject_HEAD_INIT(0)
33034 0, /* Number of items in variable part (ob_size) */
33035 (char *)"swigvarlink", /* Type name (tp_name) */
33036 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
33037 0, /* Itemsize (tp_itemsize) */
33038 0, /* Deallocator (tp_dealloc) */
33039 (printfunc) swig_varlink_print, /* Print (tp_print) */
33040 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
33041 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
33042 0, /* tp_compare */
33043 (reprfunc) swig_varlink_repr, /* tp_repr */
33044 0, /* tp_as_number */
33045 0, /* tp_as_sequence */
33046 0, /* tp_as_mapping */
33047 0, /* tp_hash */
33048 0, /* tp_call */
33049 0, /* tp_str */
33050 0, /* tp_getattro */
33051 0, /* tp_setattro */
33052 0, /* tp_as_buffer */
33053 0, /* tp_flags */
33054 0, /* tp_doc */
33055 #if PY_VERSION_HEX >= 0x02000000
33056 0, /* tp_traverse */
33057 0, /* tp_clear */
33058 #endif
33059 #if PY_VERSION_HEX >= 0x02010000
33060 0, /* tp_richcompare */
33061 0, /* tp_weaklistoffset */
33062 #endif
33063 #if PY_VERSION_HEX >= 0x02020000
33064 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33065 #endif
33066 #if PY_VERSION_HEX >= 0x02030000
33067 0, /* tp_del */
33068 #endif
33069 #ifdef COUNT_ALLOCS
33070 0,0,0,0 /* tp_alloc -> tp_next */
33071 #endif
33072 };
33073
33074 /* Create a variable linking object for use later */
33075 static PyObject *
33076 SWIG_Python_newvarlink(void) {
33077 swig_varlinkobject *result = 0;
33078 result = PyMem_NEW(swig_varlinkobject,1);
33079 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33080 result->ob_type = &varlinktype;
33081 result->vars = 0;
33082 result->ob_refcnt = 0;
33083 Py_XINCREF((PyObject *) result);
33084 return ((PyObject*) result);
33085 }
33086
33087 static void
33088 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33089 swig_varlinkobject *v;
33090 swig_globalvar *gv;
33091 v= (swig_varlinkobject *) p;
33092 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33093 gv->name = (char *) malloc(strlen(name)+1);
33094 strcpy(gv->name,name);
33095 gv->get_attr = get_attr;
33096 gv->set_attr = set_attr;
33097 gv->next = v->vars;
33098 v->vars = gv;
33099 }
33100
33101 /* -----------------------------------------------------------------------------
33102 * constants/methods manipulation
33103 * ----------------------------------------------------------------------------- */
33104
33105 /* Install Constants */
33106 static void
33107 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33108 PyObject *obj = 0;
33109 size_t i;
33110 for (i = 0; constants[i].type; i++) {
33111 switch(constants[i].type) {
33112 case SWIG_PY_INT:
33113 obj = PyInt_FromLong(constants[i].lvalue);
33114 break;
33115 case SWIG_PY_FLOAT:
33116 obj = PyFloat_FromDouble(constants[i].dvalue);
33117 break;
33118 case SWIG_PY_STRING:
33119 if (constants[i].pvalue) {
33120 obj = PyString_FromString((char *) constants[i].pvalue);
33121 } else {
33122 Py_INCREF(Py_None);
33123 obj = Py_None;
33124 }
33125 break;
33126 case SWIG_PY_POINTER:
33127 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33128 break;
33129 case SWIG_PY_BINARY:
33130 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33131 break;
33132 default:
33133 obj = 0;
33134 break;
33135 }
33136 if (obj) {
33137 PyDict_SetItemString(d,constants[i].name,obj);
33138 Py_DECREF(obj);
33139 }
33140 }
33141 }
33142
33143 /* -----------------------------------------------------------------------------*/
33144 /* Fix SwigMethods to carry the callback ptrs when needed */
33145 /* -----------------------------------------------------------------------------*/
33146
33147 static void
33148 SWIG_Python_FixMethods(PyMethodDef *methods,
33149 swig_const_info *const_table,
33150 swig_type_info **types,
33151 swig_type_info **types_initial) {
33152 size_t i;
33153 for (i = 0; methods[i].ml_name; ++i) {
33154 char *c = methods[i].ml_doc;
33155 if (c && (c = strstr(c, "swig_ptr: "))) {
33156 int j;
33157 swig_const_info *ci = 0;
33158 char *name = c + 10;
33159 for (j = 0; const_table[j].type; j++) {
33160 if (strncmp(const_table[j].name, name,
33161 strlen(const_table[j].name)) == 0) {
33162 ci = &(const_table[j]);
33163 break;
33164 }
33165 }
33166 if (ci) {
33167 size_t shift = (ci->ptype) - types;
33168 swig_type_info *ty = types_initial[shift];
33169 size_t ldoc = (c - methods[i].ml_doc);
33170 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33171 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33172 char *buff = ndoc;
33173 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33174 strncpy(buff, methods[i].ml_doc, ldoc);
33175 buff += ldoc;
33176 strncpy(buff, "swig_ptr: ", 10);
33177 buff += 10;
33178 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33179 methods[i].ml_doc = ndoc;
33180 }
33181 }
33182 }
33183 }
33184
33185 /* -----------------------------------------------------------------------------*
33186 * Initialize type list
33187 * -----------------------------------------------------------------------------*/
33188
33189 #if PY_MAJOR_VERSION < 2
33190 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33191 is copied out of Python/modsupport.c in python version 2.3.4 */
33192 static int
33193 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33194 {
33195 PyObject *dict;
33196 if (!PyModule_Check(m)) {
33197 PyErr_SetString(PyExc_TypeError,
33198 "PyModule_AddObject() needs module as first arg");
33199 return -1;
33200 }
33201 if (!o) {
33202 PyErr_SetString(PyExc_TypeError,
33203 "PyModule_AddObject() needs non-NULL value");
33204 return -1;
33205 }
33206
33207 dict = PyModule_GetDict(m);
33208 if (dict == NULL) {
33209 /* Internal error -- modules must have a dict! */
33210 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33211 PyModule_GetName(m));
33212 return -1;
33213 }
33214 if (PyDict_SetItemString(dict, name, o))
33215 return -1;
33216 Py_DECREF(o);
33217 return 0;
33218 }
33219 #endif
33220
33221 static swig_type_info **
33222 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33223 static PyMethodDef swig_empty_runtime_method_table[] = {
33224 {
33225 NULL, NULL, 0, NULL
33226 }
33227 };/* Sentinel */
33228
33229 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33230 swig_empty_runtime_method_table);
33231 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33232 if (pointer && module) {
33233 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33234 }
33235 return type_list_handle;
33236 }
33237
33238 static swig_type_info **
33239 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33240 swig_type_info **type_pointer;
33241
33242 /* first check if module already created */
33243 type_pointer = SWIG_Python_GetTypeListHandle();
33244 if (type_pointer) {
33245 return type_pointer;
33246 } else {
33247 /* create a new module and variable */
33248 return SWIG_Python_SetTypeListHandle(type_list_handle);
33249 }
33250 }
33251
33252 #ifdef __cplusplus
33253 }
33254 #endif
33255
33256 /* -----------------------------------------------------------------------------*
33257 * Partial Init method
33258 * -----------------------------------------------------------------------------*/
33259
33260 #ifdef SWIG_LINK_RUNTIME
33261 #ifdef __cplusplus
33262 extern "C"
33263 #endif
33264 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33265 #endif
33266
33267 #ifdef __cplusplus
33268 extern "C"
33269 #endif
33270 SWIGEXPORT(void) SWIG_init(void) {
33271 static PyObject *SWIG_globals = 0;
33272 static int typeinit = 0;
33273 PyObject *m, *d;
33274 int i;
33275 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33276
33277 /* Fix SwigMethods to carry the callback ptrs when needed */
33278 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33279
33280 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33281 d = PyModule_GetDict(m);
33282
33283 if (!typeinit) {
33284 #ifdef SWIG_LINK_RUNTIME
33285 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33286 #else
33287 # ifndef SWIG_STATIC_RUNTIME
33288 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33289 # endif
33290 #endif
33291 for (i = 0; swig_types_initial[i]; i++) {
33292 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33293 }
33294 typeinit = 1;
33295 }
33296 SWIG_InstallConstants(d,swig_const_table);
33297
33298 {
33299 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33345 }
33346 {
33347 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33348 }
33349 {
33350 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33351 }
33352 {
33353 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33354 }
33355 {
33356 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33570 }
33571 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33572 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33573 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33574 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33575 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33576 {
33577 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33587 }
33588 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33589
33590 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33591
33592 {
33593 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33624 }
33625 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33626 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33627 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33628 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33629 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33630 {
33631 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33644 }
33645 {
33646 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33647 }
33648 {
33649 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33650 }
33651 {
33652 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33653 }
33654 {
33655 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33656 }
33657 {
33658 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33659 }
33660 {
33661 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33662 }
33663 {
33664 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33665 }
33666 {
33667 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33668 }
33669 {
33670 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33671 }
33672 {
33673 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33674 }
33675 {
33676 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33677 }
33678 {
33679 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33680 }
33681 {
33682 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33683 }
33684 {
33685 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33686 }
33687 {
33688 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33689 }
33690 {
33691 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33713 }
33714 {
33715 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33716 }
33717 {
33718 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33719 }
33720 {
33721 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33722 }
33723 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33724 {
33725 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33738 }
33739
33740 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33741
33742 {
33743 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33762 }
33763 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33764 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33765 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33766 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33767 {
33768 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33769 }
33770 {
33771 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33772 }
33773 {
33774 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33790 }
33791 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33792 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33793 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33794 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33795 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33796 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33797 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33798 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33799 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33800 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33801 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33802 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33803 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33804 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33805 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33806 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33807 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33808 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33809 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33810 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33811 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33812 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33813 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33814 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33815 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33816 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33817 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33818 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33819 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33820 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33821 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33822 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33823 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33824 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33825 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33826 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33827 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33828 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33829 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33830 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33831 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33832 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33833 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33834 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33835 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33836 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33837 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33838 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33839 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33840 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33841 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33842 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33843 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33844 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33845 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33846 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33847
33848 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33849
33850 {
33851 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33876 }
33877 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33878 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33879 {
33880 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34283 }
34284 {
34285 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34286 }
34287 {
34288 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34289 }
34290 {
34291 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34292 }
34293 {
34294 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34295 }
34296 {
34297 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34298 }
34299 {
34300 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34301 }
34302 {
34303 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34304 }
34305 {
34306 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34307 }
34308 {
34309 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34310 }
34311 {
34312 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34313 }
34314 {
34315 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34316 }
34317 {
34318 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34319 }
34320 {
34321 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34322 }
34323 {
34324 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34325 }
34326 {
34327 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34328 }
34329 {
34330 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34343 }
34344 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34345 {
34346 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34347 }
34348 {
34349 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34350 }
34351 {
34352 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34353 }
34354 {
34355 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34356 }
34357 {
34358 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34359 }
34360 {
34361 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34362 }
34363 {
34364 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34365 }
34366 {
34367 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34368 }
34369 {
34370 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34371 }
34372 {
34373 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34374 }
34375 {
34376 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34377 }
34378 {
34379 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34380 }
34381 {
34382 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34383 }
34384 {
34385 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34386 }
34387 {
34388 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34389 }
34390 {
34391 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34392 }
34393 {
34394 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34395 }
34396 {
34397 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34398 }
34399 {
34400 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34401 }
34402 {
34403 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34404 }
34405 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34406 {
34407 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34408 }
34409 {
34410 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34411 }
34412 {
34413 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34414 }
34415 {
34416 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34417 }
34418 {
34419 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34420 }
34421 {
34422 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34423 }
34424 {
34425 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34426 }
34427 {
34428 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34429 }
34430 {
34431 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34432 }
34433 {
34434 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34435 }
34436 {
34437 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34438 }
34439 {
34440 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34441 }
34442
34443 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34444 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34445 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34446 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34447
34448 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34449 }
34450
wxWidgets (Impactor)