]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bumped subrelease number
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 bool blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 bool blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 bool blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 bool blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 bool blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 bool blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 bool blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 bool blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260 iconIndex = loc.GetIndex();
2261
2262 // Make a tuple and put the values in it
2263 bool blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 bool blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 bool blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518
2519 #if UINT_MAX < LONG_MAX
2520 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2521 #define SWIG_From_unsigned_SS_int SWIG_From_long
2522 /*@@*/
2523 #else
2524 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2525 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2526 /*@@*/
2527 #endif
2528
2529 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2530 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2531 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2532 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2533 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2534 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2535 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2536 return (*self < *other);
2537 }
2538 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2539 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2540 return (*self <= *other);
2541 }
2542 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2543 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2544 return (*self > *other);
2545 }
2546 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2547 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2548 return (*self >= *other);
2549 }
2550 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2551 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2552 return (*self == *other);
2553 }
2554 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2555 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2556 return (*self != *other);
2557 }
2558 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2559 const wxChar* rv;
2560 const wxChar* _date = date;
2561 rv = self->ParseRfc822Date(_date);
2562 if (rv == NULL) return -1;
2563 return rv - _date;
2564 }
2565 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2566 const wxChar* rv;
2567 const wxChar* _date = date;
2568 rv = self->ParseFormat(_date, format, dateDef);
2569 if (rv == NULL) return -1;
2570 return rv - _date;
2571 }
2572 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2573 const wxChar* rv;
2574 const wxChar* _datetime = datetime;
2575 rv = self->ParseDateTime(_datetime);
2576 if (rv == NULL) return -1;
2577 return rv - _datetime;
2578 }
2579 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2580 const wxChar* rv;
2581 const wxChar* _date = date;
2582 rv = self->ParseDate(_date);
2583 if (rv == NULL) return -1;
2584 return rv - _date;
2585 }
2586 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2587 const wxChar* rv;
2588 const wxChar* _time = time;
2589 rv = self->ParseTime(_time);
2590 if (rv == NULL) return -1;
2591 return rv - _time;
2592 }
2593 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2594 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2595 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2596 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2597 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2598 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2599 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2600 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2601 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2602 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2603 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2604 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2605 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2606 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2607 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2608 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2609
2610 #include <wx/dataobj.h>
2611
2612 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2613 size_t count = self->GetFormatCount(dir);
2614 wxDataFormat* formats = new wxDataFormat[count];
2615 self->GetAllFormats(formats, dir);
2616
2617 bool blocked = wxPyBeginBlockThreads();
2618 PyObject* list = PyList_New(count);
2619 for (size_t i=0; i<count; i++) {
2620 wxDataFormat* format = new wxDataFormat(formats[i]);
2621 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2622 PyList_Append(list, obj);
2623 Py_DECREF(obj);
2624 }
2625 wxPyEndBlockThreads(blocked);
2626 delete [] formats;
2627 return list;
2628 }
2629 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2630 PyObject* rval = NULL;
2631 size_t size = self->GetDataSize(format);
2632 bool blocked = wxPyBeginBlockThreads();
2633 if (size) {
2634 char* buf = new char[size];
2635 if (self->GetDataHere(format, buf))
2636 rval = PyString_FromStringAndSize(buf, size);
2637 delete [] buf;
2638 }
2639 if (! rval) {
2640 rval = Py_None;
2641 Py_INCREF(rval);
2642 }
2643 wxPyEndBlockThreads(blocked);
2644 return rval;
2645 }
2646 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2647 bool rval;
2648 bool blocked = wxPyBeginBlockThreads();
2649 if (PyString_Check(data)) {
2650 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2651 }
2652 else {
2653 // raise a TypeError if not a string
2654 PyErr_SetString(PyExc_TypeError, "String expected.");
2655 rval = false;
2656 }
2657 wxPyEndBlockThreads(blocked);
2658 return rval;
2659 }
2660 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2661 PyObject* rval = NULL;
2662 size_t size = self->GetDataSize();
2663 bool blocked = wxPyBeginBlockThreads();
2664 if (size) {
2665 char* buf = new char[size];
2666 if (self->GetDataHere(buf))
2667 rval = PyString_FromStringAndSize(buf, size);
2668 delete [] buf;
2669 }
2670 if (! rval) {
2671 rval = Py_None;
2672 Py_INCREF(rval);
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2678 bool rval;
2679 bool blocked = wxPyBeginBlockThreads();
2680 if (PyString_Check(data)) {
2681 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2682 }
2683 else {
2684 // raise a TypeError if not a string
2685 PyErr_SetString(PyExc_TypeError, "String expected.");
2686 rval = false;
2687 }
2688 wxPyEndBlockThreads(blocked);
2689 return rval;
2690 }
2691 // Create a new class for wxPython to use
2692 class wxPyDataObjectSimple : public wxDataObjectSimple {
2693 public:
2694 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2695 : wxDataObjectSimple(format) {}
2696
2697 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2698 bool GetDataHere(void *buf) const;
2699 bool SetData(size_t len, const void *buf) const;
2700 PYPRIVATE;
2701 };
2702
2703 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2704
2705 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2706 // We need to get the data for this object and write it to buf. I think
2707 // the best way to do this for wxPython is to have the Python method
2708 // return either a string or None and then act appropriately with the
2709 // C++ version.
2710
2711 bool rval = false;
2712 bool blocked = wxPyBeginBlockThreads();
2713 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2714 PyObject* ro;
2715 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2716 if (ro) {
2717 rval = (ro != Py_None && PyString_Check(ro));
2718 if (rval)
2719 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2720 Py_DECREF(ro);
2721 }
2722 }
2723 wxPyEndBlockThreads(blocked);
2724 return rval;
2725 }
2726
2727 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2728 // For this one we simply need to make a string from buf and len
2729 // and send it to the Python method.
2730 bool rval = false;
2731 bool blocked = wxPyBeginBlockThreads();
2732 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2733 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2734 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2735 Py_DECREF(data);
2736 }
2737 wxPyEndBlockThreads(blocked);
2738 return rval;
2739 }
2740
2741 // Create a new class for wxPython to use
2742 class wxPyTextDataObject : public wxTextDataObject {
2743 public:
2744 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2745 : wxTextDataObject(text) {}
2746
2747 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2748 DEC_PYCALLBACK_STRING__const(GetText);
2749 DEC_PYCALLBACK__STRING(SetText);
2750 PYPRIVATE;
2751 };
2752
2753 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2754 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2755 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2756
2757
2758 // Create a new class for wxPython to use
2759 class wxPyBitmapDataObject : public wxBitmapDataObject {
2760 public:
2761 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2762 : wxBitmapDataObject(bitmap) {}
2763
2764 wxBitmap GetBitmap() const;
2765 void SetBitmap(const wxBitmap& bitmap);
2766 PYPRIVATE;
2767 };
2768
2769 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2770 wxBitmap* rval = &wxNullBitmap;
2771 bool blocked = wxPyBeginBlockThreads();
2772 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2773 PyObject* ro;
2774 wxBitmap* ptr;
2775 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2776 if (ro) {
2777 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2778 rval = ptr;
2779 Py_DECREF(ro);
2780 }
2781 }
2782 wxPyEndBlockThreads(blocked);
2783 return *rval;
2784 }
2785
2786 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2787 bool blocked = wxPyBeginBlockThreads();
2788 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2789 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2790 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2791 Py_DECREF(bo);
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 }
2795
2796 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2797 return new wxCustomDataObject(wxDataFormat(formatName));
2798 }
2799 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2800 bool rval;
2801 bool blocked = wxPyBeginBlockThreads();
2802 if (PyString_Check(data)) {
2803 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2804 }
2805 else {
2806 // raise a TypeError if not a string
2807 PyErr_SetString(PyExc_TypeError, "String expected.");
2808 rval = false;
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 return rval;
2812 }
2813 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2814 PyObject* obj;
2815 bool blocked = wxPyBeginBlockThreads();
2816 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2817 wxPyEndBlockThreads(blocked);
2818 return obj;
2819 }
2820
2821 #include <wx/metafile.h>
2822
2823
2824 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2825
2826
2827 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2828 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2829 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2830 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2831 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2832
2833
2834 class wxPyTextDropTarget : public wxTextDropTarget {
2835 public:
2836 wxPyTextDropTarget() {}
2837
2838 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2839
2840 DEC_PYCALLBACK__(OnLeave);
2841 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2842 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2843 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2844 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2845
2846 PYPRIVATE;
2847 };
2848
2849 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2850 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2851 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2852 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2854 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2855
2856
2857
2858 class wxPyFileDropTarget : public wxFileDropTarget {
2859 public:
2860 wxPyFileDropTarget() {}
2861
2862 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2863
2864 DEC_PYCALLBACK__(OnLeave);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2868 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2869
2870 PYPRIVATE;
2871 };
2872
2873 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2874 const wxArrayString& filenames) {
2875 bool rval = false;
2876 bool blocked = wxPyBeginBlockThreads();
2877 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2878 PyObject* list = wxArrayString2PyList_helper(filenames);
2879 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2880 Py_DECREF(list);
2881 }
2882 wxPyEndBlockThreads(blocked);
2883 return rval;
2884 }
2885
2886
2887
2888 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2889 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2890 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2891 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2892 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2893
2894
2895
2896
2897 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2898
2899 #include <wx/display.h>
2900
2901 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2902 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2903
2904 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2905 #if !wxUSE_DISPLAY
2906 #include <wx/dynarray.h>
2907 #include <wx/vidmode.h>
2908
2909 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2910 #include "wx/arrimpl.cpp"
2911 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2912 const wxVideoMode wxDefaultVideoMode;
2913
2914 class wxDisplay
2915 {
2916 public:
2917 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2918 ~wxDisplay() {}
2919
2920 static size_t GetCount()
2921 { wxPyRaiseNotImplemented(); return 0; }
2922
2923 static int GetFromPoint(const wxPoint& pt)
2924 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2925 static int GetFromWindow(wxWindow *window)
2926 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2927
2928 virtual bool IsOk() const { return false; }
2929 virtual wxRect GetGeometry() const { wxRect r; return r; }
2930 virtual wxString GetName() const { return wxEmptyString; }
2931 bool IsPrimary() const { return false; }
2932
2933 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2934 { wxArrayVideoModes a; return a; }
2935
2936 virtual wxVideoMode GetCurrentMode() const
2937 { return wxDefaultVideoMode; }
2938
2939 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2940 { return false; }
2941
2942 void ResetMode() {}
2943 };
2944 #endif
2945
2946 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2947 PyObject* pyList = NULL;
2948 wxArrayVideoModes arr = self->GetModes(mode);
2949 bool blocked = wxPyBeginBlockThreads();
2950 pyList = PyList_New(0);
2951 for (int i=0; i < arr.GetCount(); i++) {
2952 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2953 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2954 PyList_Append(pyList, pyObj);
2955 Py_DECREF(pyObj);
2956 }
2957 wxPyEndBlockThreads(blocked);
2958 return pyList;
2959 }
2960
2961 #include <wx/stdpaths.h>
2962
2963 static wxStandardPaths *StandardPaths_Get(){
2964 return (wxStandardPaths*) &wxStandardPaths::Get();
2965 }
2966 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2967 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2968 #ifdef __cplusplus
2969 extern "C" {
2970 #endif
2971 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2972 PyObject *resultobj;
2973 wxSystemColour arg1 ;
2974 wxColour result;
2975 PyObject * obj0 = 0 ;
2976 char *kwnames[] = {
2977 (char *) "index", NULL
2978 };
2979
2980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2981 {
2982 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2983 if (SWIG_arg_fail(1)) SWIG_fail;
2984 }
2985 {
2986 if (!wxPyCheckForApp()) SWIG_fail;
2987 PyThreadState* __tstate = wxPyBeginAllowThreads();
2988 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2989
2990 wxPyEndAllowThreads(__tstate);
2991 if (PyErr_Occurred()) SWIG_fail;
2992 }
2993 {
2994 wxColour * resultptr;
2995 resultptr = new wxColour((wxColour &)(result));
2996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2997 }
2998 return resultobj;
2999 fail:
3000 return NULL;
3001 }
3002
3003
3004 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3005 PyObject *resultobj;
3006 wxSystemFont arg1 ;
3007 wxFont result;
3008 PyObject * obj0 = 0 ;
3009 char *kwnames[] = {
3010 (char *) "index", NULL
3011 };
3012
3013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3014 {
3015 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3016 if (SWIG_arg_fail(1)) SWIG_fail;
3017 }
3018 {
3019 if (!wxPyCheckForApp()) SWIG_fail;
3020 PyThreadState* __tstate = wxPyBeginAllowThreads();
3021 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3022
3023 wxPyEndAllowThreads(__tstate);
3024 if (PyErr_Occurred()) SWIG_fail;
3025 }
3026 {
3027 wxFont * resultptr;
3028 resultptr = new wxFont((wxFont &)(result));
3029 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3030 }
3031 return resultobj;
3032 fail:
3033 return NULL;
3034 }
3035
3036
3037 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3038 PyObject *resultobj;
3039 wxSystemMetric arg1 ;
3040 int result;
3041 PyObject * obj0 = 0 ;
3042 char *kwnames[] = {
3043 (char *) "index", NULL
3044 };
3045
3046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3047 {
3048 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3049 if (SWIG_arg_fail(1)) SWIG_fail;
3050 }
3051 {
3052 if (!wxPyCheckForApp()) SWIG_fail;
3053 PyThreadState* __tstate = wxPyBeginAllowThreads();
3054 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3055
3056 wxPyEndAllowThreads(__tstate);
3057 if (PyErr_Occurred()) SWIG_fail;
3058 }
3059 {
3060 resultobj = SWIG_From_int((int)(result));
3061 }
3062 return resultobj;
3063 fail:
3064 return NULL;
3065 }
3066
3067
3068 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3069 PyObject *resultobj;
3070 wxSystemFeature arg1 ;
3071 bool result;
3072 PyObject * obj0 = 0 ;
3073 char *kwnames[] = {
3074 (char *) "index", NULL
3075 };
3076
3077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3078 {
3079 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3080 if (SWIG_arg_fail(1)) SWIG_fail;
3081 }
3082 {
3083 if (!wxPyCheckForApp()) SWIG_fail;
3084 PyThreadState* __tstate = wxPyBeginAllowThreads();
3085 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3086
3087 wxPyEndAllowThreads(__tstate);
3088 if (PyErr_Occurred()) SWIG_fail;
3089 }
3090 {
3091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3092 }
3093 return resultobj;
3094 fail:
3095 return NULL;
3096 }
3097
3098
3099 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3100 PyObject *resultobj;
3101 wxSystemScreenType result;
3102 char *kwnames[] = {
3103 NULL
3104 };
3105
3106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3107 {
3108 if (!wxPyCheckForApp()) SWIG_fail;
3109 PyThreadState* __tstate = wxPyBeginAllowThreads();
3110 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3111
3112 wxPyEndAllowThreads(__tstate);
3113 if (PyErr_Occurred()) SWIG_fail;
3114 }
3115 resultobj = SWIG_From_int((result));
3116 return resultobj;
3117 fail:
3118 return NULL;
3119 }
3120
3121
3122 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3123 PyObject *resultobj;
3124 wxSystemScreenType arg1 ;
3125 PyObject * obj0 = 0 ;
3126 char *kwnames[] = {
3127 (char *) "screen", NULL
3128 };
3129
3130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3131 {
3132 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3133 if (SWIG_arg_fail(1)) SWIG_fail;
3134 }
3135 {
3136 if (!wxPyCheckForApp()) SWIG_fail;
3137 PyThreadState* __tstate = wxPyBeginAllowThreads();
3138 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3139
3140 wxPyEndAllowThreads(__tstate);
3141 if (PyErr_Occurred()) SWIG_fail;
3142 }
3143 Py_INCREF(Py_None); resultobj = Py_None;
3144 return resultobj;
3145 fail:
3146 return NULL;
3147 }
3148
3149
3150 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3151 PyObject *obj;
3152 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3153 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3154 Py_INCREF(obj);
3155 return Py_BuildValue((char *)"");
3156 }
3157 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3158 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3159 return 1;
3160 }
3161
3162
3163 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3164 PyObject *pyobj;
3165
3166 {
3167 #if wxUSE_UNICODE
3168 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3169 #else
3170 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3171 #endif
3172 }
3173 return pyobj;
3174 }
3175
3176
3177 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3178 PyObject *resultobj;
3179 wxSystemOptions *result;
3180 char *kwnames[] = {
3181 NULL
3182 };
3183
3184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3185 {
3186 PyThreadState* __tstate = wxPyBeginAllowThreads();
3187 result = (wxSystemOptions *)new wxSystemOptions();
3188
3189 wxPyEndAllowThreads(__tstate);
3190 if (PyErr_Occurred()) SWIG_fail;
3191 }
3192 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3193 return resultobj;
3194 fail:
3195 return NULL;
3196 }
3197
3198
3199 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3200 PyObject *resultobj;
3201 wxString *arg1 = 0 ;
3202 wxString *arg2 = 0 ;
3203 bool temp1 = false ;
3204 bool temp2 = false ;
3205 PyObject * obj0 = 0 ;
3206 PyObject * obj1 = 0 ;
3207 char *kwnames[] = {
3208 (char *) "name",(char *) "value", NULL
3209 };
3210
3211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3212 {
3213 arg1 = wxString_in_helper(obj0);
3214 if (arg1 == NULL) SWIG_fail;
3215 temp1 = true;
3216 }
3217 {
3218 arg2 = wxString_in_helper(obj1);
3219 if (arg2 == NULL) SWIG_fail;
3220 temp2 = true;
3221 }
3222 {
3223 PyThreadState* __tstate = wxPyBeginAllowThreads();
3224 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3225
3226 wxPyEndAllowThreads(__tstate);
3227 if (PyErr_Occurred()) SWIG_fail;
3228 }
3229 Py_INCREF(Py_None); resultobj = Py_None;
3230 {
3231 if (temp1)
3232 delete arg1;
3233 }
3234 {
3235 if (temp2)
3236 delete arg2;
3237 }
3238 return resultobj;
3239 fail:
3240 {
3241 if (temp1)
3242 delete arg1;
3243 }
3244 {
3245 if (temp2)
3246 delete arg2;
3247 }
3248 return NULL;
3249 }
3250
3251
3252 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3253 PyObject *resultobj;
3254 wxString *arg1 = 0 ;
3255 int arg2 ;
3256 bool temp1 = false ;
3257 PyObject * obj0 = 0 ;
3258 PyObject * obj1 = 0 ;
3259 char *kwnames[] = {
3260 (char *) "name",(char *) "value", NULL
3261 };
3262
3263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3264 {
3265 arg1 = wxString_in_helper(obj0);
3266 if (arg1 == NULL) SWIG_fail;
3267 temp1 = true;
3268 }
3269 {
3270 arg2 = (int)(SWIG_As_int(obj1));
3271 if (SWIG_arg_fail(2)) SWIG_fail;
3272 }
3273 {
3274 PyThreadState* __tstate = wxPyBeginAllowThreads();
3275 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3276
3277 wxPyEndAllowThreads(__tstate);
3278 if (PyErr_Occurred()) SWIG_fail;
3279 }
3280 Py_INCREF(Py_None); resultobj = Py_None;
3281 {
3282 if (temp1)
3283 delete arg1;
3284 }
3285 return resultobj;
3286 fail:
3287 {
3288 if (temp1)
3289 delete arg1;
3290 }
3291 return NULL;
3292 }
3293
3294
3295 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3296 PyObject *resultobj;
3297 wxString *arg1 = 0 ;
3298 wxString result;
3299 bool temp1 = false ;
3300 PyObject * obj0 = 0 ;
3301 char *kwnames[] = {
3302 (char *) "name", NULL
3303 };
3304
3305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3306 {
3307 arg1 = wxString_in_helper(obj0);
3308 if (arg1 == NULL) SWIG_fail;
3309 temp1 = true;
3310 }
3311 {
3312 PyThreadState* __tstate = wxPyBeginAllowThreads();
3313 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3314
3315 wxPyEndAllowThreads(__tstate);
3316 if (PyErr_Occurred()) SWIG_fail;
3317 }
3318 {
3319 #if wxUSE_UNICODE
3320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3321 #else
3322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3323 #endif
3324 }
3325 {
3326 if (temp1)
3327 delete arg1;
3328 }
3329 return resultobj;
3330 fail:
3331 {
3332 if (temp1)
3333 delete arg1;
3334 }
3335 return NULL;
3336 }
3337
3338
3339 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3340 PyObject *resultobj;
3341 wxString *arg1 = 0 ;
3342 int result;
3343 bool temp1 = false ;
3344 PyObject * obj0 = 0 ;
3345 char *kwnames[] = {
3346 (char *) "name", NULL
3347 };
3348
3349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3350 {
3351 arg1 = wxString_in_helper(obj0);
3352 if (arg1 == NULL) SWIG_fail;
3353 temp1 = true;
3354 }
3355 {
3356 PyThreadState* __tstate = wxPyBeginAllowThreads();
3357 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3358
3359 wxPyEndAllowThreads(__tstate);
3360 if (PyErr_Occurred()) SWIG_fail;
3361 }
3362 {
3363 resultobj = SWIG_From_int((int)(result));
3364 }
3365 {
3366 if (temp1)
3367 delete arg1;
3368 }
3369 return resultobj;
3370 fail:
3371 {
3372 if (temp1)
3373 delete arg1;
3374 }
3375 return NULL;
3376 }
3377
3378
3379 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3380 PyObject *resultobj;
3381 wxString *arg1 = 0 ;
3382 bool result;
3383 bool temp1 = false ;
3384 PyObject * obj0 = 0 ;
3385 char *kwnames[] = {
3386 (char *) "name", NULL
3387 };
3388
3389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3390 {
3391 arg1 = wxString_in_helper(obj0);
3392 if (arg1 == NULL) SWIG_fail;
3393 temp1 = true;
3394 }
3395 {
3396 PyThreadState* __tstate = wxPyBeginAllowThreads();
3397 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3398
3399 wxPyEndAllowThreads(__tstate);
3400 if (PyErr_Occurred()) SWIG_fail;
3401 }
3402 {
3403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3404 }
3405 {
3406 if (temp1)
3407 delete arg1;
3408 }
3409 return resultobj;
3410 fail:
3411 {
3412 if (temp1)
3413 delete arg1;
3414 }
3415 return NULL;
3416 }
3417
3418
3419 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3420 PyObject *obj;
3421 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3422 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3423 Py_INCREF(obj);
3424 return Py_BuildValue((char *)"");
3425 }
3426 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3427 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3428 return 1;
3429 }
3430
3431
3432 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3433 PyObject *pyobj;
3434
3435 {
3436 #if wxUSE_UNICODE
3437 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3438 #else
3439 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3440 #endif
3441 }
3442 return pyobj;
3443 }
3444
3445
3446 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3447 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3448 return 1;
3449 }
3450
3451
3452 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3453 PyObject *pyobj;
3454
3455 {
3456 #if wxUSE_UNICODE
3457 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3458 #else
3459 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3460 #endif
3461 }
3462 return pyobj;
3463 }
3464
3465
3466 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3467 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3468 return 1;
3469 }
3470
3471
3472 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3473 PyObject *pyobj;
3474
3475 {
3476 #if wxUSE_UNICODE
3477 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3478 #else
3479 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3480 #endif
3481 }
3482 return pyobj;
3483 }
3484
3485
3486 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3487 PyObject *resultobj;
3488 long result;
3489 char *kwnames[] = {
3490 NULL
3491 };
3492
3493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3494 {
3495 PyThreadState* __tstate = wxPyBeginAllowThreads();
3496 result = (long)wxNewId();
3497
3498 wxPyEndAllowThreads(__tstate);
3499 if (PyErr_Occurred()) SWIG_fail;
3500 }
3501 {
3502 resultobj = SWIG_From_long((long)(result));
3503 }
3504 return resultobj;
3505 fail:
3506 return NULL;
3507 }
3508
3509
3510 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3511 PyObject *resultobj;
3512 long arg1 ;
3513 PyObject * obj0 = 0 ;
3514 char *kwnames[] = {
3515 (char *) "id", NULL
3516 };
3517
3518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3519 {
3520 arg1 = (long)(SWIG_As_long(obj0));
3521 if (SWIG_arg_fail(1)) SWIG_fail;
3522 }
3523 {
3524 PyThreadState* __tstate = wxPyBeginAllowThreads();
3525 wxRegisterId(arg1);
3526
3527 wxPyEndAllowThreads(__tstate);
3528 if (PyErr_Occurred()) SWIG_fail;
3529 }
3530 Py_INCREF(Py_None); resultobj = Py_None;
3531 return resultobj;
3532 fail:
3533 return NULL;
3534 }
3535
3536
3537 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3538 PyObject *resultobj;
3539 long result;
3540 char *kwnames[] = {
3541 NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3545 {
3546 PyThreadState* __tstate = wxPyBeginAllowThreads();
3547 result = (long)wxGetCurrentId();
3548
3549 wxPyEndAllowThreads(__tstate);
3550 if (PyErr_Occurred()) SWIG_fail;
3551 }
3552 {
3553 resultobj = SWIG_From_long((long)(result));
3554 }
3555 return resultobj;
3556 fail:
3557 return NULL;
3558 }
3559
3560
3561 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3562 PyObject *resultobj;
3563 int arg1 ;
3564 bool result;
3565 PyObject * obj0 = 0 ;
3566 char *kwnames[] = {
3567 (char *) "id", NULL
3568 };
3569
3570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3571 {
3572 arg1 = (int)(SWIG_As_int(obj0));
3573 if (SWIG_arg_fail(1)) SWIG_fail;
3574 }
3575 {
3576 PyThreadState* __tstate = wxPyBeginAllowThreads();
3577 result = (bool)wxIsStockID(arg1);
3578
3579 wxPyEndAllowThreads(__tstate);
3580 if (PyErr_Occurred()) SWIG_fail;
3581 }
3582 {
3583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3584 }
3585 return resultobj;
3586 fail:
3587 return NULL;
3588 }
3589
3590
3591 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3592 PyObject *resultobj;
3593 int arg1 ;
3594 wxString *arg2 = 0 ;
3595 bool result;
3596 bool temp2 = false ;
3597 PyObject * obj0 = 0 ;
3598 PyObject * obj1 = 0 ;
3599 char *kwnames[] = {
3600 (char *) "id",(char *) "label", NULL
3601 };
3602
3603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3604 {
3605 arg1 = (int)(SWIG_As_int(obj0));
3606 if (SWIG_arg_fail(1)) SWIG_fail;
3607 }
3608 {
3609 arg2 = wxString_in_helper(obj1);
3610 if (arg2 == NULL) SWIG_fail;
3611 temp2 = true;
3612 }
3613 {
3614 PyThreadState* __tstate = wxPyBeginAllowThreads();
3615 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3616
3617 wxPyEndAllowThreads(__tstate);
3618 if (PyErr_Occurred()) SWIG_fail;
3619 }
3620 {
3621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3622 }
3623 {
3624 if (temp2)
3625 delete arg2;
3626 }
3627 return resultobj;
3628 fail:
3629 {
3630 if (temp2)
3631 delete arg2;
3632 }
3633 return NULL;
3634 }
3635
3636
3637 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3638 PyObject *resultobj;
3639 int arg1 ;
3640 bool arg2 = (bool) true ;
3641 wxString arg3 = (wxString) wxPyEmptyString ;
3642 wxString result;
3643 PyObject * obj0 = 0 ;
3644 PyObject * obj1 = 0 ;
3645 PyObject * obj2 = 0 ;
3646 char *kwnames[] = {
3647 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3648 };
3649
3650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3651 {
3652 arg1 = (int)(SWIG_As_int(obj0));
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 }
3655 if (obj1) {
3656 {
3657 arg2 = (bool)(SWIG_As_bool(obj1));
3658 if (SWIG_arg_fail(2)) SWIG_fail;
3659 }
3660 }
3661 if (obj2) {
3662 {
3663 wxString* sptr = wxString_in_helper(obj2);
3664 if (sptr == NULL) SWIG_fail;
3665 arg3 = *sptr;
3666 delete sptr;
3667 }
3668 }
3669 {
3670 PyThreadState* __tstate = wxPyBeginAllowThreads();
3671 result = wxGetStockLabel(arg1,arg2,arg3);
3672
3673 wxPyEndAllowThreads(__tstate);
3674 if (PyErr_Occurred()) SWIG_fail;
3675 }
3676 {
3677 #if wxUSE_UNICODE
3678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3679 #else
3680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3681 #endif
3682 }
3683 return resultobj;
3684 fail:
3685 return NULL;
3686 }
3687
3688
3689 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3690 PyObject *resultobj;
3691 char *kwnames[] = {
3692 NULL
3693 };
3694
3695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3696 {
3697 if (!wxPyCheckForApp()) SWIG_fail;
3698 PyThreadState* __tstate = wxPyBeginAllowThreads();
3699 wxBell();
3700
3701 wxPyEndAllowThreads(__tstate);
3702 if (PyErr_Occurred()) SWIG_fail;
3703 }
3704 Py_INCREF(Py_None); resultobj = Py_None;
3705 return resultobj;
3706 fail:
3707 return NULL;
3708 }
3709
3710
3711 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3712 PyObject *resultobj;
3713 char *kwnames[] = {
3714 NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3718 {
3719 if (!wxPyCheckForApp()) SWIG_fail;
3720 PyThreadState* __tstate = wxPyBeginAllowThreads();
3721 wxEndBusyCursor();
3722
3723 wxPyEndAllowThreads(__tstate);
3724 if (PyErr_Occurred()) SWIG_fail;
3725 }
3726 Py_INCREF(Py_None); resultobj = Py_None;
3727 return resultobj;
3728 fail:
3729 return NULL;
3730 }
3731
3732
3733 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3734 PyObject *resultobj;
3735 bool arg1 = (bool) true ;
3736 long result;
3737 PyObject * obj0 = 0 ;
3738 char *kwnames[] = {
3739 (char *) "resetTimer", NULL
3740 };
3741
3742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3743 if (obj0) {
3744 {
3745 arg1 = (bool)(SWIG_As_bool(obj0));
3746 if (SWIG_arg_fail(1)) SWIG_fail;
3747 }
3748 }
3749 {
3750 PyThreadState* __tstate = wxPyBeginAllowThreads();
3751 result = (long)wxGetElapsedTime(arg1);
3752
3753 wxPyEndAllowThreads(__tstate);
3754 if (PyErr_Occurred()) SWIG_fail;
3755 }
3756 {
3757 resultobj = SWIG_From_long((long)(result));
3758 }
3759 return resultobj;
3760 fail:
3761 return NULL;
3762 }
3763
3764
3765 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3766 PyObject *resultobj;
3767 int *arg1 = (int *) 0 ;
3768 int *arg2 = (int *) 0 ;
3769 int temp1 ;
3770 int res1 = 0 ;
3771 int temp2 ;
3772 int res2 = 0 ;
3773 char *kwnames[] = {
3774 NULL
3775 };
3776
3777 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3778 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3780 {
3781 if (!wxPyCheckForApp()) SWIG_fail;
3782 PyThreadState* __tstate = wxPyBeginAllowThreads();
3783 wxGetMousePosition(arg1,arg2);
3784
3785 wxPyEndAllowThreads(__tstate);
3786 if (PyErr_Occurred()) SWIG_fail;
3787 }
3788 Py_INCREF(Py_None); resultobj = Py_None;
3789 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3790 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3791 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3792 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3793 return resultobj;
3794 fail:
3795 return NULL;
3796 }
3797
3798
3799 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3800 PyObject *resultobj;
3801 bool result;
3802 char *kwnames[] = {
3803 NULL
3804 };
3805
3806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3807 {
3808 PyThreadState* __tstate = wxPyBeginAllowThreads();
3809 result = (bool)wxIsBusy();
3810
3811 wxPyEndAllowThreads(__tstate);
3812 if (PyErr_Occurred()) SWIG_fail;
3813 }
3814 {
3815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3816 }
3817 return resultobj;
3818 fail:
3819 return NULL;
3820 }
3821
3822
3823 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3824 PyObject *resultobj;
3825 wxString result;
3826 char *kwnames[] = {
3827 NULL
3828 };
3829
3830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3831 {
3832 PyThreadState* __tstate = wxPyBeginAllowThreads();
3833 result = wxNow();
3834
3835 wxPyEndAllowThreads(__tstate);
3836 if (PyErr_Occurred()) SWIG_fail;
3837 }
3838 {
3839 #if wxUSE_UNICODE
3840 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3841 #else
3842 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3843 #endif
3844 }
3845 return resultobj;
3846 fail:
3847 return NULL;
3848 }
3849
3850
3851 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3852 PyObject *resultobj;
3853 wxString const &arg1_defvalue = wxPyEmptyString ;
3854 wxString *arg1 = (wxString *) &arg1_defvalue ;
3855 bool result;
3856 bool temp1 = false ;
3857 PyObject * obj0 = 0 ;
3858 char *kwnames[] = {
3859 (char *) "command", NULL
3860 };
3861
3862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3863 if (obj0) {
3864 {
3865 arg1 = wxString_in_helper(obj0);
3866 if (arg1 == NULL) SWIG_fail;
3867 temp1 = true;
3868 }
3869 }
3870 {
3871 PyThreadState* __tstate = wxPyBeginAllowThreads();
3872 result = (bool)wxShell((wxString const &)*arg1);
3873
3874 wxPyEndAllowThreads(__tstate);
3875 if (PyErr_Occurred()) SWIG_fail;
3876 }
3877 {
3878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3879 }
3880 {
3881 if (temp1)
3882 delete arg1;
3883 }
3884 return resultobj;
3885 fail:
3886 {
3887 if (temp1)
3888 delete arg1;
3889 }
3890 return NULL;
3891 }
3892
3893
3894 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3895 PyObject *resultobj;
3896 char *kwnames[] = {
3897 NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 wxStartTimer();
3904
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 Py_INCREF(Py_None); resultobj = Py_None;
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3916 PyObject *resultobj;
3917 int *arg1 = (int *) 0 ;
3918 int *arg2 = (int *) 0 ;
3919 int result;
3920 int temp1 ;
3921 int res1 = 0 ;
3922 int temp2 ;
3923 int res2 = 0 ;
3924 char *kwnames[] = {
3925 NULL
3926 };
3927
3928 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3929 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (int)wxGetOsVersion(arg1,arg2);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 {
3939 resultobj = SWIG_From_int((int)(result));
3940 }
3941 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3942 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3943 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3944 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3945 return resultobj;
3946 fail:
3947 return NULL;
3948 }
3949
3950
3951 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3952 PyObject *resultobj;
3953 wxString result;
3954 char *kwnames[] = {
3955 NULL
3956 };
3957
3958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3959 {
3960 PyThreadState* __tstate = wxPyBeginAllowThreads();
3961 result = wxGetOsDescription();
3962
3963 wxPyEndAllowThreads(__tstate);
3964 if (PyErr_Occurred()) SWIG_fail;
3965 }
3966 {
3967 #if wxUSE_UNICODE
3968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3969 #else
3970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3971 #endif
3972 }
3973 return resultobj;
3974 fail:
3975 return NULL;
3976 }
3977
3978
3979 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3980 PyObject *resultobj;
3981 long result;
3982 char *kwnames[] = {
3983 NULL
3984 };
3985
3986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3987 {
3988 PyThreadState* __tstate = wxPyBeginAllowThreads();
3989 result = (long)wxGetFreeMemory();
3990
3991 wxPyEndAllowThreads(__tstate);
3992 if (PyErr_Occurred()) SWIG_fail;
3993 }
3994 {
3995 resultobj = SWIG_From_long((long)(result));
3996 }
3997 return resultobj;
3998 fail:
3999 return NULL;
4000 }
4001
4002
4003 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4004 PyObject *resultobj;
4005 wxShutdownFlags arg1 ;
4006 bool result;
4007 PyObject * obj0 = 0 ;
4008 char *kwnames[] = {
4009 (char *) "wFlags", NULL
4010 };
4011
4012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4013 {
4014 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4015 if (SWIG_arg_fail(1)) SWIG_fail;
4016 }
4017 {
4018 if (!wxPyCheckForApp()) SWIG_fail;
4019 PyThreadState* __tstate = wxPyBeginAllowThreads();
4020 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4021
4022 wxPyEndAllowThreads(__tstate);
4023 if (PyErr_Occurred()) SWIG_fail;
4024 }
4025 {
4026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4027 }
4028 return resultobj;
4029 fail:
4030 return NULL;
4031 }
4032
4033
4034 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4035 PyObject *resultobj;
4036 int arg1 ;
4037 PyObject * obj0 = 0 ;
4038 char *kwnames[] = {
4039 (char *) "secs", NULL
4040 };
4041
4042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4043 {
4044 arg1 = (int)(SWIG_As_int(obj0));
4045 if (SWIG_arg_fail(1)) SWIG_fail;
4046 }
4047 {
4048 PyThreadState* __tstate = wxPyBeginAllowThreads();
4049 wxSleep(arg1);
4050
4051 wxPyEndAllowThreads(__tstate);
4052 if (PyErr_Occurred()) SWIG_fail;
4053 }
4054 Py_INCREF(Py_None); resultobj = Py_None;
4055 return resultobj;
4056 fail:
4057 return NULL;
4058 }
4059
4060
4061 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4062 PyObject *resultobj;
4063 unsigned long arg1 ;
4064 PyObject * obj0 = 0 ;
4065 char *kwnames[] = {
4066 (char *) "milliseconds", NULL
4067 };
4068
4069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4070 {
4071 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4072 if (SWIG_arg_fail(1)) SWIG_fail;
4073 }
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 wxMilliSleep(arg1);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 Py_INCREF(Py_None); resultobj = Py_None;
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 unsigned long arg1 ;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "microseconds", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4097 {
4098 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4099 if (SWIG_arg_fail(1)) SWIG_fail;
4100 }
4101 {
4102 PyThreadState* __tstate = wxPyBeginAllowThreads();
4103 wxMicroSleep(arg1);
4104
4105 wxPyEndAllowThreads(__tstate);
4106 if (PyErr_Occurred()) SWIG_fail;
4107 }
4108 Py_INCREF(Py_None); resultobj = Py_None;
4109 return resultobj;
4110 fail:
4111 return NULL;
4112 }
4113
4114
4115 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4116 PyObject *resultobj;
4117 bool arg1 ;
4118 PyObject * obj0 = 0 ;
4119 char *kwnames[] = {
4120 (char *) "enable", NULL
4121 };
4122
4123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4124 {
4125 arg1 = (bool)(SWIG_As_bool(obj0));
4126 if (SWIG_arg_fail(1)) SWIG_fail;
4127 }
4128 {
4129 PyThreadState* __tstate = wxPyBeginAllowThreads();
4130 wxEnableTopLevelWindows(arg1);
4131
4132 wxPyEndAllowThreads(__tstate);
4133 if (PyErr_Occurred()) SWIG_fail;
4134 }
4135 Py_INCREF(Py_None); resultobj = Py_None;
4136 return resultobj;
4137 fail:
4138 return NULL;
4139 }
4140
4141
4142 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4143 PyObject *resultobj;
4144 wxString *arg1 = 0 ;
4145 wxString result;
4146 bool temp1 = false ;
4147 PyObject * obj0 = 0 ;
4148 char *kwnames[] = {
4149 (char *) "in", NULL
4150 };
4151
4152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4153 {
4154 arg1 = wxString_in_helper(obj0);
4155 if (arg1 == NULL) SWIG_fail;
4156 temp1 = true;
4157 }
4158 {
4159 PyThreadState* __tstate = wxPyBeginAllowThreads();
4160 result = wxStripMenuCodes((wxString const &)*arg1);
4161
4162 wxPyEndAllowThreads(__tstate);
4163 if (PyErr_Occurred()) SWIG_fail;
4164 }
4165 {
4166 #if wxUSE_UNICODE
4167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4168 #else
4169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4170 #endif
4171 }
4172 {
4173 if (temp1)
4174 delete arg1;
4175 }
4176 return resultobj;
4177 fail:
4178 {
4179 if (temp1)
4180 delete arg1;
4181 }
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 wxString result;
4189 char *kwnames[] = {
4190 NULL
4191 };
4192
4193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4194 {
4195 PyThreadState* __tstate = wxPyBeginAllowThreads();
4196 result = wxGetEmailAddress();
4197
4198 wxPyEndAllowThreads(__tstate);
4199 if (PyErr_Occurred()) SWIG_fail;
4200 }
4201 {
4202 #if wxUSE_UNICODE
4203 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4204 #else
4205 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4206 #endif
4207 }
4208 return resultobj;
4209 fail:
4210 return NULL;
4211 }
4212
4213
4214 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4215 PyObject *resultobj;
4216 wxString result;
4217 char *kwnames[] = {
4218 NULL
4219 };
4220
4221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4222 {
4223 PyThreadState* __tstate = wxPyBeginAllowThreads();
4224 result = wxGetHostName();
4225
4226 wxPyEndAllowThreads(__tstate);
4227 if (PyErr_Occurred()) SWIG_fail;
4228 }
4229 {
4230 #if wxUSE_UNICODE
4231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4232 #else
4233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4234 #endif
4235 }
4236 return resultobj;
4237 fail:
4238 return NULL;
4239 }
4240
4241
4242 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4243 PyObject *resultobj;
4244 wxString result;
4245 char *kwnames[] = {
4246 NULL
4247 };
4248
4249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4250 {
4251 PyThreadState* __tstate = wxPyBeginAllowThreads();
4252 result = wxGetFullHostName();
4253
4254 wxPyEndAllowThreads(__tstate);
4255 if (PyErr_Occurred()) SWIG_fail;
4256 }
4257 {
4258 #if wxUSE_UNICODE
4259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4260 #else
4261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4262 #endif
4263 }
4264 return resultobj;
4265 fail:
4266 return NULL;
4267 }
4268
4269
4270 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4271 PyObject *resultobj;
4272 wxString result;
4273 char *kwnames[] = {
4274 NULL
4275 };
4276
4277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4278 {
4279 PyThreadState* __tstate = wxPyBeginAllowThreads();
4280 result = wxGetUserId();
4281
4282 wxPyEndAllowThreads(__tstate);
4283 if (PyErr_Occurred()) SWIG_fail;
4284 }
4285 {
4286 #if wxUSE_UNICODE
4287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4288 #else
4289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4290 #endif
4291 }
4292 return resultobj;
4293 fail:
4294 return NULL;
4295 }
4296
4297
4298 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4299 PyObject *resultobj;
4300 wxString result;
4301 char *kwnames[] = {
4302 NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = wxGetUserName();
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 {
4314 #if wxUSE_UNICODE
4315 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4316 #else
4317 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4318 #endif
4319 }
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj;
4328 wxString result;
4329 char *kwnames[] = {
4330 NULL
4331 };
4332
4333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4334 {
4335 PyThreadState* __tstate = wxPyBeginAllowThreads();
4336 result = wxGetHomeDir();
4337
4338 wxPyEndAllowThreads(__tstate);
4339 if (PyErr_Occurred()) SWIG_fail;
4340 }
4341 {
4342 #if wxUSE_UNICODE
4343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4344 #else
4345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4346 #endif
4347 }
4348 return resultobj;
4349 fail:
4350 return NULL;
4351 }
4352
4353
4354 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4355 PyObject *resultobj;
4356 wxString const &arg1_defvalue = wxPyEmptyString ;
4357 wxString *arg1 = (wxString *) &arg1_defvalue ;
4358 wxString result;
4359 bool temp1 = false ;
4360 PyObject * obj0 = 0 ;
4361 char *kwnames[] = {
4362 (char *) "user", NULL
4363 };
4364
4365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4366 if (obj0) {
4367 {
4368 arg1 = wxString_in_helper(obj0);
4369 if (arg1 == NULL) SWIG_fail;
4370 temp1 = true;
4371 }
4372 }
4373 {
4374 PyThreadState* __tstate = wxPyBeginAllowThreads();
4375 result = wxGetUserHome((wxString const &)*arg1);
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 {
4388 if (temp1)
4389 delete arg1;
4390 }
4391 return resultobj;
4392 fail:
4393 {
4394 if (temp1)
4395 delete arg1;
4396 }
4397 return NULL;
4398 }
4399
4400
4401 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4402 PyObject *resultobj;
4403 unsigned long result;
4404 char *kwnames[] = {
4405 NULL
4406 };
4407
4408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4409 {
4410 PyThreadState* __tstate = wxPyBeginAllowThreads();
4411 result = (unsigned long)wxGetProcessId();
4412
4413 wxPyEndAllowThreads(__tstate);
4414 if (PyErr_Occurred()) SWIG_fail;
4415 }
4416 {
4417 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 char *kwnames[] = {
4428 NULL
4429 };
4430
4431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4432 {
4433 PyThreadState* __tstate = wxPyBeginAllowThreads();
4434 wxTrap();
4435
4436 wxPyEndAllowThreads(__tstate);
4437 if (PyErr_Occurred()) SWIG_fail;
4438 }
4439 Py_INCREF(Py_None); resultobj = Py_None;
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4447 PyObject *resultobj;
4448 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4449 wxString *arg1 = (wxString *) &arg1_defvalue ;
4450 wxString const &arg2_defvalue = wxPyEmptyString ;
4451 wxString *arg2 = (wxString *) &arg2_defvalue ;
4452 wxString const &arg3_defvalue = wxPyEmptyString ;
4453 wxString *arg3 = (wxString *) &arg3_defvalue ;
4454 wxString const &arg4_defvalue = wxPyEmptyString ;
4455 wxString *arg4 = (wxString *) &arg4_defvalue ;
4456 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4457 wxString *arg5 = (wxString *) &arg5_defvalue ;
4458 int arg6 = (int) 0 ;
4459 wxWindow *arg7 = (wxWindow *) NULL ;
4460 int arg8 = (int) -1 ;
4461 int arg9 = (int) -1 ;
4462 wxString result;
4463 bool temp1 = false ;
4464 bool temp2 = false ;
4465 bool temp3 = false ;
4466 bool temp4 = false ;
4467 bool temp5 = false ;
4468 PyObject * obj0 = 0 ;
4469 PyObject * obj1 = 0 ;
4470 PyObject * obj2 = 0 ;
4471 PyObject * obj3 = 0 ;
4472 PyObject * obj4 = 0 ;
4473 PyObject * obj5 = 0 ;
4474 PyObject * obj6 = 0 ;
4475 PyObject * obj7 = 0 ;
4476 PyObject * obj8 = 0 ;
4477 char *kwnames[] = {
4478 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4479 };
4480
4481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4482 if (obj0) {
4483 {
4484 arg1 = wxString_in_helper(obj0);
4485 if (arg1 == NULL) SWIG_fail;
4486 temp1 = true;
4487 }
4488 }
4489 if (obj1) {
4490 {
4491 arg2 = wxString_in_helper(obj1);
4492 if (arg2 == NULL) SWIG_fail;
4493 temp2 = true;
4494 }
4495 }
4496 if (obj2) {
4497 {
4498 arg3 = wxString_in_helper(obj2);
4499 if (arg3 == NULL) SWIG_fail;
4500 temp3 = true;
4501 }
4502 }
4503 if (obj3) {
4504 {
4505 arg4 = wxString_in_helper(obj3);
4506 if (arg4 == NULL) SWIG_fail;
4507 temp4 = true;
4508 }
4509 }
4510 if (obj4) {
4511 {
4512 arg5 = wxString_in_helper(obj4);
4513 if (arg5 == NULL) SWIG_fail;
4514 temp5 = true;
4515 }
4516 }
4517 if (obj5) {
4518 {
4519 arg6 = (int)(SWIG_As_int(obj5));
4520 if (SWIG_arg_fail(6)) SWIG_fail;
4521 }
4522 }
4523 if (obj6) {
4524 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4525 if (SWIG_arg_fail(7)) SWIG_fail;
4526 }
4527 if (obj7) {
4528 {
4529 arg8 = (int)(SWIG_As_int(obj7));
4530 if (SWIG_arg_fail(8)) SWIG_fail;
4531 }
4532 }
4533 if (obj8) {
4534 {
4535 arg9 = (int)(SWIG_As_int(obj8));
4536 if (SWIG_arg_fail(9)) SWIG_fail;
4537 }
4538 }
4539 {
4540 if (!wxPyCheckForApp()) SWIG_fail;
4541 PyThreadState* __tstate = wxPyBeginAllowThreads();
4542 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4543
4544 wxPyEndAllowThreads(__tstate);
4545 if (PyErr_Occurred()) SWIG_fail;
4546 }
4547 {
4548 #if wxUSE_UNICODE
4549 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4550 #else
4551 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4552 #endif
4553 }
4554 {
4555 if (temp1)
4556 delete arg1;
4557 }
4558 {
4559 if (temp2)
4560 delete arg2;
4561 }
4562 {
4563 if (temp3)
4564 delete arg3;
4565 }
4566 {
4567 if (temp4)
4568 delete arg4;
4569 }
4570 {
4571 if (temp5)
4572 delete arg5;
4573 }
4574 return resultobj;
4575 fail:
4576 {
4577 if (temp1)
4578 delete arg1;
4579 }
4580 {
4581 if (temp2)
4582 delete arg2;
4583 }
4584 {
4585 if (temp3)
4586 delete arg3;
4587 }
4588 {
4589 if (temp4)
4590 delete arg4;
4591 }
4592 {
4593 if (temp5)
4594 delete arg5;
4595 }
4596 return NULL;
4597 }
4598
4599
4600 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4601 PyObject *resultobj;
4602 wxString *arg1 = 0 ;
4603 wxString *arg2 = 0 ;
4604 wxString const &arg3_defvalue = wxPyEmptyString ;
4605 wxString *arg3 = (wxString *) &arg3_defvalue ;
4606 wxWindow *arg4 = (wxWindow *) NULL ;
4607 wxString result;
4608 bool temp1 = false ;
4609 bool temp2 = false ;
4610 bool temp3 = false ;
4611 PyObject * obj0 = 0 ;
4612 PyObject * obj1 = 0 ;
4613 PyObject * obj2 = 0 ;
4614 PyObject * obj3 = 0 ;
4615 char *kwnames[] = {
4616 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4617 };
4618
4619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4620 {
4621 arg1 = wxString_in_helper(obj0);
4622 if (arg1 == NULL) SWIG_fail;
4623 temp1 = true;
4624 }
4625 {
4626 arg2 = wxString_in_helper(obj1);
4627 if (arg2 == NULL) SWIG_fail;
4628 temp2 = true;
4629 }
4630 if (obj2) {
4631 {
4632 arg3 = wxString_in_helper(obj2);
4633 if (arg3 == NULL) SWIG_fail;
4634 temp3 = true;
4635 }
4636 }
4637 if (obj3) {
4638 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4639 if (SWIG_arg_fail(4)) SWIG_fail;
4640 }
4641 {
4642 if (!wxPyCheckForApp()) SWIG_fail;
4643 PyThreadState* __tstate = wxPyBeginAllowThreads();
4644 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4645
4646 wxPyEndAllowThreads(__tstate);
4647 if (PyErr_Occurred()) SWIG_fail;
4648 }
4649 {
4650 #if wxUSE_UNICODE
4651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4652 #else
4653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4654 #endif
4655 }
4656 {
4657 if (temp1)
4658 delete arg1;
4659 }
4660 {
4661 if (temp2)
4662 delete arg2;
4663 }
4664 {
4665 if (temp3)
4666 delete arg3;
4667 }
4668 return resultobj;
4669 fail:
4670 {
4671 if (temp1)
4672 delete arg1;
4673 }
4674 {
4675 if (temp2)
4676 delete arg2;
4677 }
4678 {
4679 if (temp3)
4680 delete arg3;
4681 }
4682 return NULL;
4683 }
4684
4685
4686 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4687 PyObject *resultobj;
4688 wxString *arg1 = 0 ;
4689 wxString *arg2 = 0 ;
4690 wxString const &arg3_defvalue = wxPyEmptyString ;
4691 wxString *arg3 = (wxString *) &arg3_defvalue ;
4692 wxWindow *arg4 = (wxWindow *) NULL ;
4693 wxString result;
4694 bool temp1 = false ;
4695 bool temp2 = false ;
4696 bool temp3 = false ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 PyObject * obj2 = 0 ;
4700 PyObject * obj3 = 0 ;
4701 char *kwnames[] = {
4702 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4703 };
4704
4705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4706 {
4707 arg1 = wxString_in_helper(obj0);
4708 if (arg1 == NULL) SWIG_fail;
4709 temp1 = true;
4710 }
4711 {
4712 arg2 = wxString_in_helper(obj1);
4713 if (arg2 == NULL) SWIG_fail;
4714 temp2 = true;
4715 }
4716 if (obj2) {
4717 {
4718 arg3 = wxString_in_helper(obj2);
4719 if (arg3 == NULL) SWIG_fail;
4720 temp3 = true;
4721 }
4722 }
4723 if (obj3) {
4724 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4725 if (SWIG_arg_fail(4)) SWIG_fail;
4726 }
4727 {
4728 if (!wxPyCheckForApp()) SWIG_fail;
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4731
4732 wxPyEndAllowThreads(__tstate);
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 {
4736 #if wxUSE_UNICODE
4737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4738 #else
4739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4740 #endif
4741 }
4742 {
4743 if (temp1)
4744 delete arg1;
4745 }
4746 {
4747 if (temp2)
4748 delete arg2;
4749 }
4750 {
4751 if (temp3)
4752 delete arg3;
4753 }
4754 return resultobj;
4755 fail:
4756 {
4757 if (temp1)
4758 delete arg1;
4759 }
4760 {
4761 if (temp2)
4762 delete arg2;
4763 }
4764 {
4765 if (temp3)
4766 delete arg3;
4767 }
4768 return NULL;
4769 }
4770
4771
4772 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4773 PyObject *resultobj;
4774 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4775 wxString *arg1 = (wxString *) &arg1_defvalue ;
4776 wxString const &arg2_defvalue = wxPyEmptyString ;
4777 wxString *arg2 = (wxString *) &arg2_defvalue ;
4778 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4779 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4780 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4781 wxWindow *arg5 = (wxWindow *) NULL ;
4782 wxString result;
4783 bool temp1 = false ;
4784 bool temp2 = false ;
4785 wxPoint temp4 ;
4786 PyObject * obj0 = 0 ;
4787 PyObject * obj1 = 0 ;
4788 PyObject * obj2 = 0 ;
4789 PyObject * obj3 = 0 ;
4790 PyObject * obj4 = 0 ;
4791 char *kwnames[] = {
4792 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4793 };
4794
4795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4796 if (obj0) {
4797 {
4798 arg1 = wxString_in_helper(obj0);
4799 if (arg1 == NULL) SWIG_fail;
4800 temp1 = true;
4801 }
4802 }
4803 if (obj1) {
4804 {
4805 arg2 = wxString_in_helper(obj1);
4806 if (arg2 == NULL) SWIG_fail;
4807 temp2 = true;
4808 }
4809 }
4810 if (obj2) {
4811 {
4812 arg3 = (long)(SWIG_As_long(obj2));
4813 if (SWIG_arg_fail(3)) SWIG_fail;
4814 }
4815 }
4816 if (obj3) {
4817 {
4818 arg4 = &temp4;
4819 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4820 }
4821 }
4822 if (obj4) {
4823 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4824 if (SWIG_arg_fail(5)) SWIG_fail;
4825 }
4826 {
4827 if (!wxPyCheckForApp()) SWIG_fail;
4828 PyThreadState* __tstate = wxPyBeginAllowThreads();
4829 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4830
4831 wxPyEndAllowThreads(__tstate);
4832 if (PyErr_Occurred()) SWIG_fail;
4833 }
4834 {
4835 #if wxUSE_UNICODE
4836 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4837 #else
4838 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4839 #endif
4840 }
4841 {
4842 if (temp1)
4843 delete arg1;
4844 }
4845 {
4846 if (temp2)
4847 delete arg2;
4848 }
4849 return resultobj;
4850 fail:
4851 {
4852 if (temp1)
4853 delete arg1;
4854 }
4855 {
4856 if (temp2)
4857 delete arg2;
4858 }
4859 return NULL;
4860 }
4861
4862
4863 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4864 PyObject *resultobj;
4865 wxString *arg1 = 0 ;
4866 wxString const &arg2_defvalue = wxPyEmptyString ;
4867 wxString *arg2 = (wxString *) &arg2_defvalue ;
4868 wxString const &arg3_defvalue = wxPyEmptyString ;
4869 wxString *arg3 = (wxString *) &arg3_defvalue ;
4870 wxWindow *arg4 = (wxWindow *) NULL ;
4871 int arg5 = (int) -1 ;
4872 int arg6 = (int) -1 ;
4873 bool arg7 = (bool) true ;
4874 wxString result;
4875 bool temp1 = false ;
4876 bool temp2 = false ;
4877 bool temp3 = false ;
4878 PyObject * obj0 = 0 ;
4879 PyObject * obj1 = 0 ;
4880 PyObject * obj2 = 0 ;
4881 PyObject * obj3 = 0 ;
4882 PyObject * obj4 = 0 ;
4883 PyObject * obj5 = 0 ;
4884 PyObject * obj6 = 0 ;
4885 char *kwnames[] = {
4886 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4887 };
4888
4889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4890 {
4891 arg1 = wxString_in_helper(obj0);
4892 if (arg1 == NULL) SWIG_fail;
4893 temp1 = true;
4894 }
4895 if (obj1) {
4896 {
4897 arg2 = wxString_in_helper(obj1);
4898 if (arg2 == NULL) SWIG_fail;
4899 temp2 = true;
4900 }
4901 }
4902 if (obj2) {
4903 {
4904 arg3 = wxString_in_helper(obj2);
4905 if (arg3 == NULL) SWIG_fail;
4906 temp3 = true;
4907 }
4908 }
4909 if (obj3) {
4910 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4911 if (SWIG_arg_fail(4)) SWIG_fail;
4912 }
4913 if (obj4) {
4914 {
4915 arg5 = (int)(SWIG_As_int(obj4));
4916 if (SWIG_arg_fail(5)) SWIG_fail;
4917 }
4918 }
4919 if (obj5) {
4920 {
4921 arg6 = (int)(SWIG_As_int(obj5));
4922 if (SWIG_arg_fail(6)) SWIG_fail;
4923 }
4924 }
4925 if (obj6) {
4926 {
4927 arg7 = (bool)(SWIG_As_bool(obj6));
4928 if (SWIG_arg_fail(7)) SWIG_fail;
4929 }
4930 }
4931 {
4932 if (!wxPyCheckForApp()) SWIG_fail;
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4935
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 {
4940 #if wxUSE_UNICODE
4941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4942 #else
4943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4944 #endif
4945 }
4946 {
4947 if (temp1)
4948 delete arg1;
4949 }
4950 {
4951 if (temp2)
4952 delete arg2;
4953 }
4954 {
4955 if (temp3)
4956 delete arg3;
4957 }
4958 return resultobj;
4959 fail:
4960 {
4961 if (temp1)
4962 delete arg1;
4963 }
4964 {
4965 if (temp2)
4966 delete arg2;
4967 }
4968 {
4969 if (temp3)
4970 delete arg3;
4971 }
4972 return NULL;
4973 }
4974
4975
4976 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj;
4978 wxString *arg1 = 0 ;
4979 wxString const &arg2_defvalue = wxPyEmptyString ;
4980 wxString *arg2 = (wxString *) &arg2_defvalue ;
4981 wxString const &arg3_defvalue = wxPyEmptyString ;
4982 wxString *arg3 = (wxString *) &arg3_defvalue ;
4983 wxWindow *arg4 = (wxWindow *) NULL ;
4984 wxString result;
4985 bool temp1 = false ;
4986 bool temp2 = false ;
4987 bool temp3 = false ;
4988 PyObject * obj0 = 0 ;
4989 PyObject * obj1 = 0 ;
4990 PyObject * obj2 = 0 ;
4991 PyObject * obj3 = 0 ;
4992 char *kwnames[] = {
4993 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4994 };
4995
4996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4997 {
4998 arg1 = wxString_in_helper(obj0);
4999 if (arg1 == NULL) SWIG_fail;
5000 temp1 = true;
5001 }
5002 if (obj1) {
5003 {
5004 arg2 = wxString_in_helper(obj1);
5005 if (arg2 == NULL) SWIG_fail;
5006 temp2 = true;
5007 }
5008 }
5009 if (obj2) {
5010 {
5011 arg3 = wxString_in_helper(obj2);
5012 if (arg3 == NULL) SWIG_fail;
5013 temp3 = true;
5014 }
5015 }
5016 if (obj3) {
5017 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5018 if (SWIG_arg_fail(4)) SWIG_fail;
5019 }
5020 {
5021 if (!wxPyCheckForApp()) SWIG_fail;
5022 PyThreadState* __tstate = wxPyBeginAllowThreads();
5023 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5024
5025 wxPyEndAllowThreads(__tstate);
5026 if (PyErr_Occurred()) SWIG_fail;
5027 }
5028 {
5029 #if wxUSE_UNICODE
5030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5031 #else
5032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5033 #endif
5034 }
5035 {
5036 if (temp1)
5037 delete arg1;
5038 }
5039 {
5040 if (temp2)
5041 delete arg2;
5042 }
5043 {
5044 if (temp3)
5045 delete arg3;
5046 }
5047 return resultobj;
5048 fail:
5049 {
5050 if (temp1)
5051 delete arg1;
5052 }
5053 {
5054 if (temp2)
5055 delete arg2;
5056 }
5057 {
5058 if (temp3)
5059 delete arg3;
5060 }
5061 return NULL;
5062 }
5063
5064
5065 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj;
5067 wxString *arg1 = 0 ;
5068 wxString *arg2 = 0 ;
5069 int arg3 ;
5070 wxString *arg4 = (wxString *) 0 ;
5071 wxWindow *arg5 = (wxWindow *) NULL ;
5072 int arg6 = (int) -1 ;
5073 int arg7 = (int) -1 ;
5074 bool arg8 = (bool) true ;
5075 int arg9 = (int) 150 ;
5076 int arg10 = (int) 200 ;
5077 wxString result;
5078 bool temp1 = false ;
5079 bool temp2 = false ;
5080 PyObject * obj0 = 0 ;
5081 PyObject * obj1 = 0 ;
5082 PyObject * obj2 = 0 ;
5083 PyObject * obj3 = 0 ;
5084 PyObject * obj4 = 0 ;
5085 PyObject * obj5 = 0 ;
5086 PyObject * obj6 = 0 ;
5087 PyObject * obj7 = 0 ;
5088 PyObject * obj8 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5094 {
5095 arg1 = wxString_in_helper(obj0);
5096 if (arg1 == NULL) SWIG_fail;
5097 temp1 = true;
5098 }
5099 {
5100 arg2 = wxString_in_helper(obj1);
5101 if (arg2 == NULL) SWIG_fail;
5102 temp2 = true;
5103 }
5104 {
5105 arg3 = PyList_Size(obj2);
5106 arg4 = wxString_LIST_helper(obj2);
5107 if (arg4 == NULL) SWIG_fail;
5108 }
5109 if (obj3) {
5110 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5111 if (SWIG_arg_fail(5)) SWIG_fail;
5112 }
5113 if (obj4) {
5114 {
5115 arg6 = (int)(SWIG_As_int(obj4));
5116 if (SWIG_arg_fail(6)) SWIG_fail;
5117 }
5118 }
5119 if (obj5) {
5120 {
5121 arg7 = (int)(SWIG_As_int(obj5));
5122 if (SWIG_arg_fail(7)) SWIG_fail;
5123 }
5124 }
5125 if (obj6) {
5126 {
5127 arg8 = (bool)(SWIG_As_bool(obj6));
5128 if (SWIG_arg_fail(8)) SWIG_fail;
5129 }
5130 }
5131 if (obj7) {
5132 {
5133 arg9 = (int)(SWIG_As_int(obj7));
5134 if (SWIG_arg_fail(9)) SWIG_fail;
5135 }
5136 }
5137 if (obj8) {
5138 {
5139 arg10 = (int)(SWIG_As_int(obj8));
5140 if (SWIG_arg_fail(10)) SWIG_fail;
5141 }
5142 }
5143 {
5144 if (!wxPyCheckForApp()) SWIG_fail;
5145 PyThreadState* __tstate = wxPyBeginAllowThreads();
5146 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5147
5148 wxPyEndAllowThreads(__tstate);
5149 if (PyErr_Occurred()) SWIG_fail;
5150 }
5151 {
5152 #if wxUSE_UNICODE
5153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5154 #else
5155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5156 #endif
5157 }
5158 {
5159 if (temp1)
5160 delete arg1;
5161 }
5162 {
5163 if (temp2)
5164 delete arg2;
5165 }
5166 {
5167 if (arg4) delete [] arg4;
5168 }
5169 return resultobj;
5170 fail:
5171 {
5172 if (temp1)
5173 delete arg1;
5174 }
5175 {
5176 if (temp2)
5177 delete arg2;
5178 }
5179 {
5180 if (arg4) delete [] arg4;
5181 }
5182 return NULL;
5183 }
5184
5185
5186 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5187 PyObject *resultobj;
5188 wxString *arg1 = 0 ;
5189 wxString *arg2 = 0 ;
5190 int arg3 ;
5191 wxString *arg4 = (wxString *) 0 ;
5192 wxWindow *arg5 = (wxWindow *) NULL ;
5193 int arg6 = (int) -1 ;
5194 int arg7 = (int) -1 ;
5195 bool arg8 = (bool) true ;
5196 int arg9 = (int) 150 ;
5197 int arg10 = (int) 200 ;
5198 int result;
5199 bool temp1 = false ;
5200 bool temp2 = false ;
5201 PyObject * obj0 = 0 ;
5202 PyObject * obj1 = 0 ;
5203 PyObject * obj2 = 0 ;
5204 PyObject * obj3 = 0 ;
5205 PyObject * obj4 = 0 ;
5206 PyObject * obj5 = 0 ;
5207 PyObject * obj6 = 0 ;
5208 PyObject * obj7 = 0 ;
5209 PyObject * obj8 = 0 ;
5210 char *kwnames[] = {
5211 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5212 };
5213
5214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5215 {
5216 arg1 = wxString_in_helper(obj0);
5217 if (arg1 == NULL) SWIG_fail;
5218 temp1 = true;
5219 }
5220 {
5221 arg2 = wxString_in_helper(obj1);
5222 if (arg2 == NULL) SWIG_fail;
5223 temp2 = true;
5224 }
5225 {
5226 arg3 = PyList_Size(obj2);
5227 arg4 = wxString_LIST_helper(obj2);
5228 if (arg4 == NULL) SWIG_fail;
5229 }
5230 if (obj3) {
5231 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5232 if (SWIG_arg_fail(5)) SWIG_fail;
5233 }
5234 if (obj4) {
5235 {
5236 arg6 = (int)(SWIG_As_int(obj4));
5237 if (SWIG_arg_fail(6)) SWIG_fail;
5238 }
5239 }
5240 if (obj5) {
5241 {
5242 arg7 = (int)(SWIG_As_int(obj5));
5243 if (SWIG_arg_fail(7)) SWIG_fail;
5244 }
5245 }
5246 if (obj6) {
5247 {
5248 arg8 = (bool)(SWIG_As_bool(obj6));
5249 if (SWIG_arg_fail(8)) SWIG_fail;
5250 }
5251 }
5252 if (obj7) {
5253 {
5254 arg9 = (int)(SWIG_As_int(obj7));
5255 if (SWIG_arg_fail(9)) SWIG_fail;
5256 }
5257 }
5258 if (obj8) {
5259 {
5260 arg10 = (int)(SWIG_As_int(obj8));
5261 if (SWIG_arg_fail(10)) SWIG_fail;
5262 }
5263 }
5264 {
5265 if (!wxPyCheckForApp()) SWIG_fail;
5266 PyThreadState* __tstate = wxPyBeginAllowThreads();
5267 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5268
5269 wxPyEndAllowThreads(__tstate);
5270 if (PyErr_Occurred()) SWIG_fail;
5271 }
5272 {
5273 resultobj = SWIG_From_int((int)(result));
5274 }
5275 {
5276 if (temp1)
5277 delete arg1;
5278 }
5279 {
5280 if (temp2)
5281 delete arg2;
5282 }
5283 {
5284 if (arg4) delete [] arg4;
5285 }
5286 return resultobj;
5287 fail:
5288 {
5289 if (temp1)
5290 delete arg1;
5291 }
5292 {
5293 if (temp2)
5294 delete arg2;
5295 }
5296 {
5297 if (arg4) delete [] arg4;
5298 }
5299 return NULL;
5300 }
5301
5302
5303 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5304 PyObject *resultobj;
5305 wxString *arg1 = 0 ;
5306 wxString const &arg2_defvalue = wxPyEmptyString ;
5307 wxString *arg2 = (wxString *) &arg2_defvalue ;
5308 int arg3 = (int) wxOK|wxCENTRE ;
5309 wxWindow *arg4 = (wxWindow *) NULL ;
5310 int arg5 = (int) -1 ;
5311 int arg6 = (int) -1 ;
5312 int result;
5313 bool temp1 = false ;
5314 bool temp2 = false ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 PyObject * obj2 = 0 ;
5318 PyObject * obj3 = 0 ;
5319 PyObject * obj4 = 0 ;
5320 PyObject * obj5 = 0 ;
5321 char *kwnames[] = {
5322 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5323 };
5324
5325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5326 {
5327 arg1 = wxString_in_helper(obj0);
5328 if (arg1 == NULL) SWIG_fail;
5329 temp1 = true;
5330 }
5331 if (obj1) {
5332 {
5333 arg2 = wxString_in_helper(obj1);
5334 if (arg2 == NULL) SWIG_fail;
5335 temp2 = true;
5336 }
5337 }
5338 if (obj2) {
5339 {
5340 arg3 = (int)(SWIG_As_int(obj2));
5341 if (SWIG_arg_fail(3)) SWIG_fail;
5342 }
5343 }
5344 if (obj3) {
5345 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5346 if (SWIG_arg_fail(4)) SWIG_fail;
5347 }
5348 if (obj4) {
5349 {
5350 arg5 = (int)(SWIG_As_int(obj4));
5351 if (SWIG_arg_fail(5)) SWIG_fail;
5352 }
5353 }
5354 if (obj5) {
5355 {
5356 arg6 = (int)(SWIG_As_int(obj5));
5357 if (SWIG_arg_fail(6)) SWIG_fail;
5358 }
5359 }
5360 {
5361 if (!wxPyCheckForApp()) SWIG_fail;
5362 PyThreadState* __tstate = wxPyBeginAllowThreads();
5363 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5364
5365 wxPyEndAllowThreads(__tstate);
5366 if (PyErr_Occurred()) SWIG_fail;
5367 }
5368 {
5369 resultobj = SWIG_From_int((int)(result));
5370 }
5371 {
5372 if (temp1)
5373 delete arg1;
5374 }
5375 {
5376 if (temp2)
5377 delete arg2;
5378 }
5379 return resultobj;
5380 fail:
5381 {
5382 if (temp1)
5383 delete arg1;
5384 }
5385 {
5386 if (temp2)
5387 delete arg2;
5388 }
5389 return NULL;
5390 }
5391
5392
5393 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5394 PyObject *resultobj;
5395 wxString *arg1 = 0 ;
5396 wxString *arg2 = 0 ;
5397 wxString *arg3 = 0 ;
5398 long arg4 ;
5399 long arg5 = (long) 0 ;
5400 long arg6 = (long) 100 ;
5401 wxWindow *arg7 = (wxWindow *) NULL ;
5402 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5403 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5404 long result;
5405 bool temp1 = false ;
5406 bool temp2 = false ;
5407 bool temp3 = false ;
5408 wxPoint temp8 ;
5409 PyObject * obj0 = 0 ;
5410 PyObject * obj1 = 0 ;
5411 PyObject * obj2 = 0 ;
5412 PyObject * obj3 = 0 ;
5413 PyObject * obj4 = 0 ;
5414 PyObject * obj5 = 0 ;
5415 PyObject * obj6 = 0 ;
5416 PyObject * obj7 = 0 ;
5417 char *kwnames[] = {
5418 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5419 };
5420
5421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5422 {
5423 arg1 = wxString_in_helper(obj0);
5424 if (arg1 == NULL) SWIG_fail;
5425 temp1 = true;
5426 }
5427 {
5428 arg2 = wxString_in_helper(obj1);
5429 if (arg2 == NULL) SWIG_fail;
5430 temp2 = true;
5431 }
5432 {
5433 arg3 = wxString_in_helper(obj2);
5434 if (arg3 == NULL) SWIG_fail;
5435 temp3 = true;
5436 }
5437 {
5438 arg4 = (long)(SWIG_As_long(obj3));
5439 if (SWIG_arg_fail(4)) SWIG_fail;
5440 }
5441 if (obj4) {
5442 {
5443 arg5 = (long)(SWIG_As_long(obj4));
5444 if (SWIG_arg_fail(5)) SWIG_fail;
5445 }
5446 }
5447 if (obj5) {
5448 {
5449 arg6 = (long)(SWIG_As_long(obj5));
5450 if (SWIG_arg_fail(6)) SWIG_fail;
5451 }
5452 }
5453 if (obj6) {
5454 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5455 if (SWIG_arg_fail(7)) SWIG_fail;
5456 }
5457 if (obj7) {
5458 {
5459 arg8 = &temp8;
5460 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5461 }
5462 }
5463 {
5464 if (!wxPyCheckForApp()) SWIG_fail;
5465 PyThreadState* __tstate = wxPyBeginAllowThreads();
5466 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5467
5468 wxPyEndAllowThreads(__tstate);
5469 if (PyErr_Occurred()) SWIG_fail;
5470 }
5471 {
5472 resultobj = SWIG_From_long((long)(result));
5473 }
5474 {
5475 if (temp1)
5476 delete arg1;
5477 }
5478 {
5479 if (temp2)
5480 delete arg2;
5481 }
5482 {
5483 if (temp3)
5484 delete arg3;
5485 }
5486 return resultobj;
5487 fail:
5488 {
5489 if (temp1)
5490 delete arg1;
5491 }
5492 {
5493 if (temp2)
5494 delete arg2;
5495 }
5496 {
5497 if (temp3)
5498 delete arg3;
5499 }
5500 return NULL;
5501 }
5502
5503
5504 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5505 PyObject *resultobj;
5506 bool result;
5507 char *kwnames[] = {
5508 NULL
5509 };
5510
5511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5512 {
5513 if (!wxPyCheckForApp()) SWIG_fail;
5514 PyThreadState* __tstate = wxPyBeginAllowThreads();
5515 result = (bool)wxColourDisplay();
5516
5517 wxPyEndAllowThreads(__tstate);
5518 if (PyErr_Occurred()) SWIG_fail;
5519 }
5520 {
5521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5522 }
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5530 PyObject *resultobj;
5531 int result;
5532 char *kwnames[] = {
5533 NULL
5534 };
5535
5536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5537 {
5538 if (!wxPyCheckForApp()) SWIG_fail;
5539 PyThreadState* __tstate = wxPyBeginAllowThreads();
5540 result = (int)wxDisplayDepth();
5541
5542 wxPyEndAllowThreads(__tstate);
5543 if (PyErr_Occurred()) SWIG_fail;
5544 }
5545 {
5546 resultobj = SWIG_From_int((int)(result));
5547 }
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5555 PyObject *resultobj;
5556 int result;
5557 char *kwnames[] = {
5558 NULL
5559 };
5560
5561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5562 {
5563 if (!wxPyCheckForApp()) SWIG_fail;
5564 PyThreadState* __tstate = wxPyBeginAllowThreads();
5565 result = (int)wxGetDisplayDepth();
5566
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 {
5571 resultobj = SWIG_From_int((int)(result));
5572 }
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5580 PyObject *resultobj;
5581 int *arg1 = (int *) 0 ;
5582 int *arg2 = (int *) 0 ;
5583 int temp1 ;
5584 int res1 = 0 ;
5585 int temp2 ;
5586 int res2 = 0 ;
5587 char *kwnames[] = {
5588 NULL
5589 };
5590
5591 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5592 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5594 {
5595 if (!wxPyCheckForApp()) SWIG_fail;
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 wxDisplaySize(arg1,arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5604 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5605 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5606 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj;
5615 wxSize result;
5616 char *kwnames[] = {
5617 NULL
5618 };
5619
5620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5621 {
5622 if (!wxPyCheckForApp()) SWIG_fail;
5623 PyThreadState* __tstate = wxPyBeginAllowThreads();
5624 result = wxGetDisplaySize();
5625
5626 wxPyEndAllowThreads(__tstate);
5627 if (PyErr_Occurred()) SWIG_fail;
5628 }
5629 {
5630 wxSize * resultptr;
5631 resultptr = new wxSize((wxSize &)(result));
5632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5633 }
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 int *arg1 = (int *) 0 ;
5643 int *arg2 = (int *) 0 ;
5644 int temp1 ;
5645 int res1 = 0 ;
5646 int temp2 ;
5647 int res2 = 0 ;
5648 char *kwnames[] = {
5649 NULL
5650 };
5651
5652 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5653 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5655 {
5656 if (!wxPyCheckForApp()) SWIG_fail;
5657 PyThreadState* __tstate = wxPyBeginAllowThreads();
5658 wxDisplaySizeMM(arg1,arg2);
5659
5660 wxPyEndAllowThreads(__tstate);
5661 if (PyErr_Occurred()) SWIG_fail;
5662 }
5663 Py_INCREF(Py_None); resultobj = Py_None;
5664 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5665 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5666 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5667 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5668 return resultobj;
5669 fail:
5670 return NULL;
5671 }
5672
5673
5674 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5675 PyObject *resultobj;
5676 wxSize result;
5677 char *kwnames[] = {
5678 NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5682 {
5683 if (!wxPyCheckForApp()) SWIG_fail;
5684 PyThreadState* __tstate = wxPyBeginAllowThreads();
5685 result = wxGetDisplaySizeMM();
5686
5687 wxPyEndAllowThreads(__tstate);
5688 if (PyErr_Occurred()) SWIG_fail;
5689 }
5690 {
5691 wxSize * resultptr;
5692 resultptr = new wxSize((wxSize &)(result));
5693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5694 }
5695 return resultobj;
5696 fail:
5697 return NULL;
5698 }
5699
5700
5701 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5702 PyObject *resultobj;
5703 int *arg1 = (int *) 0 ;
5704 int *arg2 = (int *) 0 ;
5705 int *arg3 = (int *) 0 ;
5706 int *arg4 = (int *) 0 ;
5707 int temp1 ;
5708 int res1 = 0 ;
5709 int temp2 ;
5710 int res2 = 0 ;
5711 int temp3 ;
5712 int res3 = 0 ;
5713 int temp4 ;
5714 int res4 = 0 ;
5715 char *kwnames[] = {
5716 NULL
5717 };
5718
5719 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5720 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5721 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5722 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5724 {
5725 if (!wxPyCheckForApp()) SWIG_fail;
5726 PyThreadState* __tstate = wxPyBeginAllowThreads();
5727 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5728
5729 wxPyEndAllowThreads(__tstate);
5730 if (PyErr_Occurred()) SWIG_fail;
5731 }
5732 Py_INCREF(Py_None); resultobj = Py_None;
5733 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5734 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5735 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5736 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5737 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5738 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5739 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5740 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5741 return resultobj;
5742 fail:
5743 return NULL;
5744 }
5745
5746
5747 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5748 PyObject *resultobj;
5749 wxRect result;
5750 char *kwnames[] = {
5751 NULL
5752 };
5753
5754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5755 {
5756 if (!wxPyCheckForApp()) SWIG_fail;
5757 PyThreadState* __tstate = wxPyBeginAllowThreads();
5758 result = wxGetClientDisplayRect();
5759
5760 wxPyEndAllowThreads(__tstate);
5761 if (PyErr_Occurred()) SWIG_fail;
5762 }
5763 {
5764 wxRect * resultptr;
5765 resultptr = new wxRect((wxRect &)(result));
5766 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5767 }
5768 return resultobj;
5769 fail:
5770 return NULL;
5771 }
5772
5773
5774 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5775 PyObject *resultobj;
5776 wxCursor *arg1 = 0 ;
5777 PyObject * obj0 = 0 ;
5778 char *kwnames[] = {
5779 (char *) "cursor", NULL
5780 };
5781
5782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5783 {
5784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5785 if (SWIG_arg_fail(1)) SWIG_fail;
5786 if (arg1 == NULL) {
5787 SWIG_null_ref("wxCursor");
5788 }
5789 if (SWIG_arg_fail(1)) SWIG_fail;
5790 }
5791 {
5792 if (!wxPyCheckForApp()) SWIG_fail;
5793 PyThreadState* __tstate = wxPyBeginAllowThreads();
5794 wxSetCursor(*arg1);
5795
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 Py_INCREF(Py_None); resultobj = Py_None;
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj;
5808 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5809 PyObject * obj0 = 0 ;
5810 char *kwnames[] = {
5811 (char *) "cursor", NULL
5812 };
5813
5814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5815 if (obj0) {
5816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5817 if (SWIG_arg_fail(1)) SWIG_fail;
5818 }
5819 {
5820 if (!wxPyCheckForApp()) SWIG_fail;
5821 PyThreadState* __tstate = wxPyBeginAllowThreads();
5822 wxBeginBusyCursor(arg1);
5823
5824 wxPyEndAllowThreads(__tstate);
5825 if (PyErr_Occurred()) SWIG_fail;
5826 }
5827 Py_INCREF(Py_None); resultobj = Py_None;
5828 return resultobj;
5829 fail:
5830 return NULL;
5831 }
5832
5833
5834 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5835 PyObject *resultobj;
5836 wxWindow *result;
5837 char *kwnames[] = {
5838 NULL
5839 };
5840
5841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5842 {
5843 if (!wxPyCheckForApp()) SWIG_fail;
5844 PyThreadState* __tstate = wxPyBeginAllowThreads();
5845 result = (wxWindow *)wxGetActiveWindow();
5846
5847 wxPyEndAllowThreads(__tstate);
5848 if (PyErr_Occurred()) SWIG_fail;
5849 }
5850 {
5851 resultobj = wxPyMake_wxObject(result, 0);
5852 }
5853 return resultobj;
5854 fail:
5855 return NULL;
5856 }
5857
5858
5859 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5860 PyObject *resultobj;
5861 wxPoint *arg1 = 0 ;
5862 wxWindow *result;
5863 wxPoint temp1 ;
5864 PyObject * obj0 = 0 ;
5865 char *kwnames[] = {
5866 (char *) "pt", NULL
5867 };
5868
5869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5870 {
5871 arg1 = &temp1;
5872 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5873 }
5874 {
5875 if (!wxPyCheckForApp()) SWIG_fail;
5876 PyThreadState* __tstate = wxPyBeginAllowThreads();
5877 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5878
5879 wxPyEndAllowThreads(__tstate);
5880 if (PyErr_Occurred()) SWIG_fail;
5881 }
5882 {
5883 resultobj = wxPyMake_wxObject(result, 0);
5884 }
5885 return resultobj;
5886 fail:
5887 return NULL;
5888 }
5889
5890
5891 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5892 PyObject *resultobj;
5893 wxPoint *arg1 = 0 ;
5894 wxWindow *result;
5895 wxPoint temp1 ;
5896 PyObject * obj0 = 0 ;
5897 char *kwnames[] = {
5898 (char *) "pt", NULL
5899 };
5900
5901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5902 {
5903 arg1 = &temp1;
5904 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5905 }
5906 {
5907 if (!wxPyCheckForApp()) SWIG_fail;
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5910
5911 wxPyEndAllowThreads(__tstate);
5912 if (PyErr_Occurred()) SWIG_fail;
5913 }
5914 {
5915 resultobj = wxPyMake_wxObject(result, 0);
5916 }
5917 return resultobj;
5918 fail:
5919 return NULL;
5920 }
5921
5922
5923 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5924 PyObject *resultobj;
5925 wxWindow *arg1 = (wxWindow *) 0 ;
5926 wxWindow *result;
5927 PyObject * obj0 = 0 ;
5928 char *kwnames[] = {
5929 (char *) "win", NULL
5930 };
5931
5932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5934 if (SWIG_arg_fail(1)) SWIG_fail;
5935 {
5936 if (!wxPyCheckForApp()) SWIG_fail;
5937 PyThreadState* __tstate = wxPyBeginAllowThreads();
5938 result = (wxWindow *)wxGetTopLevelParent(arg1);
5939
5940 wxPyEndAllowThreads(__tstate);
5941 if (PyErr_Occurred()) SWIG_fail;
5942 }
5943 {
5944 resultobj = wxPyMake_wxObject(result, 0);
5945 }
5946 return resultobj;
5947 fail:
5948 return NULL;
5949 }
5950
5951
5952 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5953 PyObject *resultobj;
5954 wxKeyCode arg1 ;
5955 bool result;
5956 PyObject * obj0 = 0 ;
5957 char *kwnames[] = {
5958 (char *) "key", NULL
5959 };
5960
5961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5962 {
5963 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5964 if (SWIG_arg_fail(1)) SWIG_fail;
5965 }
5966 {
5967 if (!wxPyCheckForApp()) SWIG_fail;
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5970
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 {
5975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5976 }
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5984 PyObject *resultobj;
5985 char *kwnames[] = {
5986 NULL
5987 };
5988
5989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5990 {
5991 if (!wxPyCheckForApp()) SWIG_fail;
5992 PyThreadState* __tstate = wxPyBeginAllowThreads();
5993 wxWakeUpMainThread();
5994
5995 wxPyEndAllowThreads(__tstate);
5996 if (PyErr_Occurred()) SWIG_fail;
5997 }
5998 Py_INCREF(Py_None); resultobj = Py_None;
5999 return resultobj;
6000 fail:
6001 return NULL;
6002 }
6003
6004
6005 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6006 PyObject *resultobj;
6007 char *kwnames[] = {
6008 NULL
6009 };
6010
6011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6012 {
6013 if (!wxPyCheckForApp()) SWIG_fail;
6014 PyThreadState* __tstate = wxPyBeginAllowThreads();
6015 wxMutexGuiEnter();
6016
6017 wxPyEndAllowThreads(__tstate);
6018 if (PyErr_Occurred()) SWIG_fail;
6019 }
6020 Py_INCREF(Py_None); resultobj = Py_None;
6021 return resultobj;
6022 fail:
6023 return NULL;
6024 }
6025
6026
6027 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6028 PyObject *resultobj;
6029 char *kwnames[] = {
6030 NULL
6031 };
6032
6033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6034 {
6035 if (!wxPyCheckForApp()) SWIG_fail;
6036 PyThreadState* __tstate = wxPyBeginAllowThreads();
6037 wxMutexGuiLeave();
6038
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 Py_INCREF(Py_None); resultobj = Py_None;
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj;
6051 wxMutexGuiLocker *result;
6052 char *kwnames[] = {
6053 NULL
6054 };
6055
6056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6057 {
6058 if (!wxPyCheckForApp()) SWIG_fail;
6059 PyThreadState* __tstate = wxPyBeginAllowThreads();
6060 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6061
6062 wxPyEndAllowThreads(__tstate);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj;
6074 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6075 PyObject * obj0 = 0 ;
6076 char *kwnames[] = {
6077 (char *) "self", NULL
6078 };
6079
6080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6082 if (SWIG_arg_fail(1)) SWIG_fail;
6083 {
6084 PyThreadState* __tstate = wxPyBeginAllowThreads();
6085 delete arg1;
6086
6087 wxPyEndAllowThreads(__tstate);
6088 if (PyErr_Occurred()) SWIG_fail;
6089 }
6090 Py_INCREF(Py_None); resultobj = Py_None;
6091 return resultobj;
6092 fail:
6093 return NULL;
6094 }
6095
6096
6097 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6098 PyObject *obj;
6099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6100 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6101 Py_INCREF(obj);
6102 return Py_BuildValue((char *)"");
6103 }
6104 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6105 PyObject *resultobj;
6106 bool result;
6107 char *kwnames[] = {
6108 NULL
6109 };
6110
6111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6112 {
6113 PyThreadState* __tstate = wxPyBeginAllowThreads();
6114 result = (bool)wxThread_IsMain();
6115
6116 wxPyEndAllowThreads(__tstate);
6117 if (PyErr_Occurred()) SWIG_fail;
6118 }
6119 {
6120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6121 }
6122 return resultobj;
6123 fail:
6124 return NULL;
6125 }
6126
6127
6128 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6129 PyObject *resultobj;
6130 wxString *arg1 = 0 ;
6131 wxToolTip *result;
6132 bool temp1 = false ;
6133 PyObject * obj0 = 0 ;
6134 char *kwnames[] = {
6135 (char *) "tip", NULL
6136 };
6137
6138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6139 {
6140 arg1 = wxString_in_helper(obj0);
6141 if (arg1 == NULL) SWIG_fail;
6142 temp1 = true;
6143 }
6144 {
6145 if (!wxPyCheckForApp()) SWIG_fail;
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6148
6149 wxPyEndAllowThreads(__tstate);
6150 if (PyErr_Occurred()) SWIG_fail;
6151 }
6152 {
6153 resultobj = wxPyMake_wxObject(result, 1);
6154 }
6155 {
6156 if (temp1)
6157 delete arg1;
6158 }
6159 return resultobj;
6160 fail:
6161 {
6162 if (temp1)
6163 delete arg1;
6164 }
6165 return NULL;
6166 }
6167
6168
6169 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6170 PyObject *resultobj;
6171 wxToolTip *arg1 = (wxToolTip *) 0 ;
6172 wxString *arg2 = 0 ;
6173 bool temp2 = false ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char *kwnames[] = {
6177 (char *) "self",(char *) "tip", NULL
6178 };
6179
6180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6182 if (SWIG_arg_fail(1)) SWIG_fail;
6183 {
6184 arg2 = wxString_in_helper(obj1);
6185 if (arg2 == NULL) SWIG_fail;
6186 temp2 = true;
6187 }
6188 {
6189 PyThreadState* __tstate = wxPyBeginAllowThreads();
6190 (arg1)->SetTip((wxString const &)*arg2);
6191
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 Py_INCREF(Py_None); resultobj = Py_None;
6196 {
6197 if (temp2)
6198 delete arg2;
6199 }
6200 return resultobj;
6201 fail:
6202 {
6203 if (temp2)
6204 delete arg2;
6205 }
6206 return NULL;
6207 }
6208
6209
6210 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6211 PyObject *resultobj;
6212 wxToolTip *arg1 = (wxToolTip *) 0 ;
6213 wxString result;
6214 PyObject * obj0 = 0 ;
6215 char *kwnames[] = {
6216 (char *) "self", NULL
6217 };
6218
6219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6221 if (SWIG_arg_fail(1)) SWIG_fail;
6222 {
6223 PyThreadState* __tstate = wxPyBeginAllowThreads();
6224 result = (arg1)->GetTip();
6225
6226 wxPyEndAllowThreads(__tstate);
6227 if (PyErr_Occurred()) SWIG_fail;
6228 }
6229 {
6230 #if wxUSE_UNICODE
6231 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6232 #else
6233 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6234 #endif
6235 }
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6243 PyObject *resultobj;
6244 wxToolTip *arg1 = (wxToolTip *) 0 ;
6245 wxWindow *result;
6246 PyObject * obj0 = 0 ;
6247 char *kwnames[] = {
6248 (char *) "self", NULL
6249 };
6250
6251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 {
6255 PyThreadState* __tstate = wxPyBeginAllowThreads();
6256 result = (wxWindow *)(arg1)->GetWindow();
6257
6258 wxPyEndAllowThreads(__tstate);
6259 if (PyErr_Occurred()) SWIG_fail;
6260 }
6261 {
6262 resultobj = wxPyMake_wxObject(result, 0);
6263 }
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj;
6272 bool arg1 ;
6273 PyObject * obj0 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "flag", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6279 {
6280 arg1 = (bool)(SWIG_As_bool(obj0));
6281 if (SWIG_arg_fail(1)) SWIG_fail;
6282 }
6283 {
6284 PyThreadState* __tstate = wxPyBeginAllowThreads();
6285 wxToolTip::Enable(arg1);
6286
6287 wxPyEndAllowThreads(__tstate);
6288 if (PyErr_Occurred()) SWIG_fail;
6289 }
6290 Py_INCREF(Py_None); resultobj = Py_None;
6291 return resultobj;
6292 fail:
6293 return NULL;
6294 }
6295
6296
6297 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6298 PyObject *resultobj;
6299 long arg1 ;
6300 PyObject * obj0 = 0 ;
6301 char *kwnames[] = {
6302 (char *) "milliseconds", NULL
6303 };
6304
6305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6306 {
6307 arg1 = (long)(SWIG_As_long(obj0));
6308 if (SWIG_arg_fail(1)) SWIG_fail;
6309 }
6310 {
6311 PyThreadState* __tstate = wxPyBeginAllowThreads();
6312 wxToolTip::SetDelay(arg1);
6313
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 Py_INCREF(Py_None); resultobj = Py_None;
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6325 PyObject *obj;
6326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6327 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6328 Py_INCREF(obj);
6329 return Py_BuildValue((char *)"");
6330 }
6331 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6332 PyObject *resultobj;
6333 wxWindow *arg1 = (wxWindow *) 0 ;
6334 wxSize *arg2 = 0 ;
6335 wxCaret *result;
6336 wxSize temp2 ;
6337 PyObject * obj0 = 0 ;
6338 PyObject * obj1 = 0 ;
6339 char *kwnames[] = {
6340 (char *) "window",(char *) "size", NULL
6341 };
6342
6343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6345 if (SWIG_arg_fail(1)) SWIG_fail;
6346 {
6347 arg2 = &temp2;
6348 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6349 }
6350 {
6351 if (!wxPyCheckForApp()) SWIG_fail;
6352 PyThreadState* __tstate = wxPyBeginAllowThreads();
6353 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6354
6355 wxPyEndAllowThreads(__tstate);
6356 if (PyErr_Occurred()) SWIG_fail;
6357 }
6358 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6359 return resultobj;
6360 fail:
6361 return NULL;
6362 }
6363
6364
6365 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6366 PyObject *resultobj;
6367 wxCaret *arg1 = (wxCaret *) 0 ;
6368 PyObject * obj0 = 0 ;
6369 char *kwnames[] = {
6370 (char *) "self", NULL
6371 };
6372
6373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6375 if (SWIG_arg_fail(1)) SWIG_fail;
6376 {
6377 PyThreadState* __tstate = wxPyBeginAllowThreads();
6378 wxCaret_Destroy(arg1);
6379
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 Py_INCREF(Py_None); resultobj = Py_None;
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6391 PyObject *resultobj;
6392 wxCaret *arg1 = (wxCaret *) 0 ;
6393 bool result;
6394 PyObject * obj0 = 0 ;
6395 char *kwnames[] = {
6396 (char *) "self", NULL
6397 };
6398
6399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6401 if (SWIG_arg_fail(1)) SWIG_fail;
6402 {
6403 PyThreadState* __tstate = wxPyBeginAllowThreads();
6404 result = (bool)(arg1)->IsOk();
6405
6406 wxPyEndAllowThreads(__tstate);
6407 if (PyErr_Occurred()) SWIG_fail;
6408 }
6409 {
6410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6411 }
6412 return resultobj;
6413 fail:
6414 return NULL;
6415 }
6416
6417
6418 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6419 PyObject *resultobj;
6420 wxCaret *arg1 = (wxCaret *) 0 ;
6421 bool result;
6422 PyObject * obj0 = 0 ;
6423 char *kwnames[] = {
6424 (char *) "self", NULL
6425 };
6426
6427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6429 if (SWIG_arg_fail(1)) SWIG_fail;
6430 {
6431 PyThreadState* __tstate = wxPyBeginAllowThreads();
6432 result = (bool)(arg1)->IsVisible();
6433
6434 wxPyEndAllowThreads(__tstate);
6435 if (PyErr_Occurred()) SWIG_fail;
6436 }
6437 {
6438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6439 }
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6447 PyObject *resultobj;
6448 wxCaret *arg1 = (wxCaret *) 0 ;
6449 wxPoint result;
6450 PyObject * obj0 = 0 ;
6451 char *kwnames[] = {
6452 (char *) "self", NULL
6453 };
6454
6455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6457 if (SWIG_arg_fail(1)) SWIG_fail;
6458 {
6459 PyThreadState* __tstate = wxPyBeginAllowThreads();
6460 result = (arg1)->GetPosition();
6461
6462 wxPyEndAllowThreads(__tstate);
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 {
6466 wxPoint * resultptr;
6467 resultptr = new wxPoint((wxPoint &)(result));
6468 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6469 }
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj;
6478 wxCaret *arg1 = (wxCaret *) 0 ;
6479 int *arg2 = (int *) 0 ;
6480 int *arg3 = (int *) 0 ;
6481 int temp2 ;
6482 int res2 = 0 ;
6483 int temp3 ;
6484 int res3 = 0 ;
6485 PyObject * obj0 = 0 ;
6486 char *kwnames[] = {
6487 (char *) "self", NULL
6488 };
6489
6490 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6491 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6494 if (SWIG_arg_fail(1)) SWIG_fail;
6495 {
6496 PyThreadState* __tstate = wxPyBeginAllowThreads();
6497 (arg1)->GetPosition(arg2,arg3);
6498
6499 wxPyEndAllowThreads(__tstate);
6500 if (PyErr_Occurred()) SWIG_fail;
6501 }
6502 Py_INCREF(Py_None); resultobj = Py_None;
6503 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6504 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6505 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6506 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6507 return resultobj;
6508 fail:
6509 return NULL;
6510 }
6511
6512
6513 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6514 PyObject *resultobj;
6515 wxCaret *arg1 = (wxCaret *) 0 ;
6516 wxSize result;
6517 PyObject * obj0 = 0 ;
6518 char *kwnames[] = {
6519 (char *) "self", NULL
6520 };
6521
6522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",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)->GetSize();
6528
6529 wxPyEndAllowThreads(__tstate);
6530 if (PyErr_Occurred()) SWIG_fail;
6531 }
6532 {
6533 wxSize * resultptr;
6534 resultptr = new wxSize((wxSize &)(result));
6535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6536 }
6537 return resultobj;
6538 fail:
6539 return NULL;
6540 }
6541
6542
6543 static PyObject *_wrap_Caret_GetSizeTuple(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_GetSizeTuple",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)->GetSize(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_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6581 PyObject *resultobj;
6582 wxCaret *arg1 = (wxCaret *) 0 ;
6583 wxWindow *result;
6584 PyObject * obj0 = 0 ;
6585 char *kwnames[] = {
6586 (char *) "self", NULL
6587 };
6588
6589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",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 = (wxWindow *)(arg1)->GetWindow();
6595
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 {
6600 resultobj = wxPyMake_wxObject(result, 0);
6601 }
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6609 PyObject *resultobj;
6610 wxCaret *arg1 = (wxCaret *) 0 ;
6611 int arg2 ;
6612 int arg3 ;
6613 PyObject * obj0 = 0 ;
6614 PyObject * obj1 = 0 ;
6615 PyObject * obj2 = 0 ;
6616 char *kwnames[] = {
6617 (char *) "self",(char *) "x",(char *) "y", NULL
6618 };
6619
6620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6622 if (SWIG_arg_fail(1)) SWIG_fail;
6623 {
6624 arg2 = (int)(SWIG_As_int(obj1));
6625 if (SWIG_arg_fail(2)) SWIG_fail;
6626 }
6627 {
6628 arg3 = (int)(SWIG_As_int(obj2));
6629 if (SWIG_arg_fail(3)) SWIG_fail;
6630 }
6631 {
6632 PyThreadState* __tstate = wxPyBeginAllowThreads();
6633 (arg1)->Move(arg2,arg3);
6634
6635 wxPyEndAllowThreads(__tstate);
6636 if (PyErr_Occurred()) SWIG_fail;
6637 }
6638 Py_INCREF(Py_None); resultobj = Py_None;
6639 return resultobj;
6640 fail:
6641 return NULL;
6642 }
6643
6644
6645 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6646 PyObject *resultobj;
6647 wxCaret *arg1 = (wxCaret *) 0 ;
6648 wxPoint *arg2 = 0 ;
6649 wxPoint temp2 ;
6650 PyObject * obj0 = 0 ;
6651 PyObject * obj1 = 0 ;
6652 char *kwnames[] = {
6653 (char *) "self",(char *) "pt", NULL
6654 };
6655
6656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
6661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6662 }
6663 {
6664 PyThreadState* __tstate = wxPyBeginAllowThreads();
6665 (arg1)->Move((wxPoint const &)*arg2);
6666
6667 wxPyEndAllowThreads(__tstate);
6668 if (PyErr_Occurred()) SWIG_fail;
6669 }
6670 Py_INCREF(Py_None); resultobj = Py_None;
6671 return resultobj;
6672 fail:
6673 return NULL;
6674 }
6675
6676
6677 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6678 PyObject *resultobj;
6679 wxCaret *arg1 = (wxCaret *) 0 ;
6680 int arg2 ;
6681 int arg3 ;
6682 PyObject * obj0 = 0 ;
6683 PyObject * obj1 = 0 ;
6684 PyObject * obj2 = 0 ;
6685 char *kwnames[] = {
6686 (char *) "self",(char *) "width",(char *) "height", NULL
6687 };
6688
6689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6691 if (SWIG_arg_fail(1)) SWIG_fail;
6692 {
6693 arg2 = (int)(SWIG_As_int(obj1));
6694 if (SWIG_arg_fail(2)) SWIG_fail;
6695 }
6696 {
6697 arg3 = (int)(SWIG_As_int(obj2));
6698 if (SWIG_arg_fail(3)) SWIG_fail;
6699 }
6700 {
6701 PyThreadState* __tstate = wxPyBeginAllowThreads();
6702 (arg1)->SetSize(arg2,arg3);
6703
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 Py_INCREF(Py_None); resultobj = Py_None;
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj;
6716 wxCaret *arg1 = (wxCaret *) 0 ;
6717 wxSize *arg2 = 0 ;
6718 wxSize temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char *kwnames[] = {
6722 (char *) "self",(char *) "size", NULL
6723 };
6724
6725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6727 if (SWIG_arg_fail(1)) SWIG_fail;
6728 {
6729 arg2 = &temp2;
6730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6731 }
6732 {
6733 PyThreadState* __tstate = wxPyBeginAllowThreads();
6734 (arg1)->SetSize((wxSize const &)*arg2);
6735
6736 wxPyEndAllowThreads(__tstate);
6737 if (PyErr_Occurred()) SWIG_fail;
6738 }
6739 Py_INCREF(Py_None); resultobj = Py_None;
6740 return resultobj;
6741 fail:
6742 return NULL;
6743 }
6744
6745
6746 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6747 PyObject *resultobj;
6748 wxCaret *arg1 = (wxCaret *) 0 ;
6749 int arg2 = (int) true ;
6750 PyObject * obj0 = 0 ;
6751 PyObject * obj1 = 0 ;
6752 char *kwnames[] = {
6753 (char *) "self",(char *) "show", NULL
6754 };
6755
6756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) 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 if (obj1) {
6760 {
6761 arg2 = (int)(SWIG_As_int(obj1));
6762 if (SWIG_arg_fail(2)) SWIG_fail;
6763 }
6764 }
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 (arg1)->Show(arg2);
6768
6769 wxPyEndAllowThreads(__tstate);
6770 if (PyErr_Occurred()) SWIG_fail;
6771 }
6772 Py_INCREF(Py_None); resultobj = Py_None;
6773 return resultobj;
6774 fail:
6775 return NULL;
6776 }
6777
6778
6779 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6780 PyObject *resultobj;
6781 wxCaret *arg1 = (wxCaret *) 0 ;
6782 PyObject * obj0 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self", NULL
6785 };
6786
6787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6789 if (SWIG_arg_fail(1)) SWIG_fail;
6790 {
6791 PyThreadState* __tstate = wxPyBeginAllowThreads();
6792 (arg1)->Hide();
6793
6794 wxPyEndAllowThreads(__tstate);
6795 if (PyErr_Occurred()) SWIG_fail;
6796 }
6797 Py_INCREF(Py_None); resultobj = Py_None;
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 int result;
6807 char *kwnames[] = {
6808 NULL
6809 };
6810
6811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (int)wxCaret::GetBlinkTime();
6815
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 {
6820 resultobj = SWIG_From_int((int)(result));
6821 }
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6829 PyObject *resultobj;
6830 int arg1 ;
6831 PyObject * obj0 = 0 ;
6832 char *kwnames[] = {
6833 (char *) "milliseconds", NULL
6834 };
6835
6836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6837 {
6838 arg1 = (int)(SWIG_As_int(obj0));
6839 if (SWIG_arg_fail(1)) SWIG_fail;
6840 }
6841 {
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 wxCaret::SetBlinkTime(arg1);
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 Py_INCREF(Py_None); resultobj = Py_None;
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6856 PyObject *obj;
6857 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6858 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6859 Py_INCREF(obj);
6860 return Py_BuildValue((char *)"");
6861 }
6862 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj;
6864 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6865 wxBusyCursor *result;
6866 PyObject * obj0 = 0 ;
6867 char *kwnames[] = {
6868 (char *) "cursor", NULL
6869 };
6870
6871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6872 if (obj0) {
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 }
6876 {
6877 if (!wxPyCheckForApp()) SWIG_fail;
6878 PyThreadState* __tstate = wxPyBeginAllowThreads();
6879 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6880
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6892 PyObject *resultobj;
6893 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6894 PyObject * obj0 = 0 ;
6895 char *kwnames[] = {
6896 (char *) "self", NULL
6897 };
6898
6899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6901 if (SWIG_arg_fail(1)) SWIG_fail;
6902 {
6903 PyThreadState* __tstate = wxPyBeginAllowThreads();
6904 delete arg1;
6905
6906 wxPyEndAllowThreads(__tstate);
6907 if (PyErr_Occurred()) SWIG_fail;
6908 }
6909 Py_INCREF(Py_None); resultobj = Py_None;
6910 return resultobj;
6911 fail:
6912 return NULL;
6913 }
6914
6915
6916 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6917 PyObject *obj;
6918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6919 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6920 Py_INCREF(obj);
6921 return Py_BuildValue((char *)"");
6922 }
6923 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6924 PyObject *resultobj;
6925 wxWindow *arg1 = (wxWindow *) NULL ;
6926 wxWindowDisabler *result;
6927 PyObject * obj0 = 0 ;
6928 char *kwnames[] = {
6929 (char *) "winToSkip", NULL
6930 };
6931
6932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6933 if (obj0) {
6934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6935 if (SWIG_arg_fail(1)) SWIG_fail;
6936 }
6937 {
6938 if (!wxPyCheckForApp()) SWIG_fail;
6939 PyThreadState* __tstate = wxPyBeginAllowThreads();
6940 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6941
6942 wxPyEndAllowThreads(__tstate);
6943 if (PyErr_Occurred()) SWIG_fail;
6944 }
6945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6946 return resultobj;
6947 fail:
6948 return NULL;
6949 }
6950
6951
6952 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6953 PyObject *resultobj;
6954 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6955 PyObject * obj0 = 0 ;
6956 char *kwnames[] = {
6957 (char *) "self", NULL
6958 };
6959
6960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6962 if (SWIG_arg_fail(1)) SWIG_fail;
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 delete arg1;
6966
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 Py_INCREF(Py_None); resultobj = Py_None;
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6978 PyObject *obj;
6979 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6980 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6981 Py_INCREF(obj);
6982 return Py_BuildValue((char *)"");
6983 }
6984 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6985 PyObject *resultobj;
6986 wxString *arg1 = 0 ;
6987 wxBusyInfo *result;
6988 bool temp1 = false ;
6989 PyObject * obj0 = 0 ;
6990 char *kwnames[] = {
6991 (char *) "message", NULL
6992 };
6993
6994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6995 {
6996 arg1 = wxString_in_helper(obj0);
6997 if (arg1 == NULL) SWIG_fail;
6998 temp1 = true;
6999 }
7000 {
7001 if (!wxPyCheckForApp()) SWIG_fail;
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7004
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7009 {
7010 if (temp1)
7011 delete arg1;
7012 }
7013 return resultobj;
7014 fail:
7015 {
7016 if (temp1)
7017 delete arg1;
7018 }
7019 return NULL;
7020 }
7021
7022
7023 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7024 PyObject *resultobj;
7025 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7026 PyObject * obj0 = 0 ;
7027 char *kwnames[] = {
7028 (char *) "self", NULL
7029 };
7030
7031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7033 if (SWIG_arg_fail(1)) SWIG_fail;
7034 {
7035 PyThreadState* __tstate = wxPyBeginAllowThreads();
7036 delete arg1;
7037
7038 wxPyEndAllowThreads(__tstate);
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 Py_INCREF(Py_None); resultobj = Py_None;
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7049 PyObject *obj;
7050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7051 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7052 Py_INCREF(obj);
7053 return Py_BuildValue((char *)"");
7054 }
7055 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj;
7057 wxStopWatch *result;
7058 char *kwnames[] = {
7059 NULL
7060 };
7061
7062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 result = (wxStopWatch *)new wxStopWatch();
7066
7067 wxPyEndAllowThreads(__tstate);
7068 if (PyErr_Occurred()) SWIG_fail;
7069 }
7070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7071 return resultobj;
7072 fail:
7073 return NULL;
7074 }
7075
7076
7077 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7078 PyObject *resultobj;
7079 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7080 long arg2 = (long) 0 ;
7081 PyObject * obj0 = 0 ;
7082 PyObject * obj1 = 0 ;
7083 char *kwnames[] = {
7084 (char *) "self",(char *) "t0", NULL
7085 };
7086
7087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7089 if (SWIG_arg_fail(1)) SWIG_fail;
7090 if (obj1) {
7091 {
7092 arg2 = (long)(SWIG_As_long(obj1));
7093 if (SWIG_arg_fail(2)) SWIG_fail;
7094 }
7095 }
7096 {
7097 PyThreadState* __tstate = wxPyBeginAllowThreads();
7098 (arg1)->Start(arg2);
7099
7100 wxPyEndAllowThreads(__tstate);
7101 if (PyErr_Occurred()) SWIG_fail;
7102 }
7103 Py_INCREF(Py_None); resultobj = Py_None;
7104 return resultobj;
7105 fail:
7106 return NULL;
7107 }
7108
7109
7110 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7111 PyObject *resultobj;
7112 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7113 PyObject * obj0 = 0 ;
7114 char *kwnames[] = {
7115 (char *) "self", NULL
7116 };
7117
7118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7120 if (SWIG_arg_fail(1)) SWIG_fail;
7121 {
7122 PyThreadState* __tstate = wxPyBeginAllowThreads();
7123 (arg1)->Pause();
7124
7125 wxPyEndAllowThreads(__tstate);
7126 if (PyErr_Occurred()) SWIG_fail;
7127 }
7128 Py_INCREF(Py_None); resultobj = Py_None;
7129 return resultobj;
7130 fail:
7131 return NULL;
7132 }
7133
7134
7135 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7136 PyObject *resultobj;
7137 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7138 PyObject * obj0 = 0 ;
7139 char *kwnames[] = {
7140 (char *) "self", NULL
7141 };
7142
7143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7145 if (SWIG_arg_fail(1)) SWIG_fail;
7146 {
7147 PyThreadState* __tstate = wxPyBeginAllowThreads();
7148 (arg1)->Resume();
7149
7150 wxPyEndAllowThreads(__tstate);
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 Py_INCREF(Py_None); resultobj = Py_None;
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7161 PyObject *resultobj;
7162 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7163 long result;
7164 PyObject * obj0 = 0 ;
7165 char *kwnames[] = {
7166 (char *) "self", NULL
7167 };
7168
7169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7171 if (SWIG_arg_fail(1)) SWIG_fail;
7172 {
7173 PyThreadState* __tstate = wxPyBeginAllowThreads();
7174 result = (long)((wxStopWatch const *)arg1)->Time();
7175
7176 wxPyEndAllowThreads(__tstate);
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 {
7180 resultobj = SWIG_From_long((long)(result));
7181 }
7182 return resultobj;
7183 fail:
7184 return NULL;
7185 }
7186
7187
7188 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7189 PyObject *obj;
7190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7191 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7192 Py_INCREF(obj);
7193 return Py_BuildValue((char *)"");
7194 }
7195 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 int arg1 = (int) 9 ;
7198 int arg2 = (int) wxID_FILE1 ;
7199 wxFileHistory *result;
7200 PyObject * obj0 = 0 ;
7201 PyObject * obj1 = 0 ;
7202 char *kwnames[] = {
7203 (char *) "maxFiles",(char *) "idBase", NULL
7204 };
7205
7206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7207 if (obj0) {
7208 {
7209 arg1 = (int)(SWIG_As_int(obj0));
7210 if (SWIG_arg_fail(1)) SWIG_fail;
7211 }
7212 }
7213 if (obj1) {
7214 {
7215 arg2 = (int)(SWIG_As_int(obj1));
7216 if (SWIG_arg_fail(2)) SWIG_fail;
7217 }
7218 }
7219 {
7220 PyThreadState* __tstate = wxPyBeginAllowThreads();
7221 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7222
7223 wxPyEndAllowThreads(__tstate);
7224 if (PyErr_Occurred()) SWIG_fail;
7225 }
7226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7227 return resultobj;
7228 fail:
7229 return NULL;
7230 }
7231
7232
7233 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7234 PyObject *resultobj;
7235 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7236 PyObject * obj0 = 0 ;
7237 char *kwnames[] = {
7238 (char *) "self", NULL
7239 };
7240
7241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7243 if (SWIG_arg_fail(1)) SWIG_fail;
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 delete arg1;
7247
7248 wxPyEndAllowThreads(__tstate);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 Py_INCREF(Py_None); resultobj = Py_None;
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj;
7260 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7261 wxString *arg2 = 0 ;
7262 bool temp2 = false ;
7263 PyObject * obj0 = 0 ;
7264 PyObject * obj1 = 0 ;
7265 char *kwnames[] = {
7266 (char *) "self",(char *) "file", NULL
7267 };
7268
7269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7271 if (SWIG_arg_fail(1)) SWIG_fail;
7272 {
7273 arg2 = wxString_in_helper(obj1);
7274 if (arg2 == NULL) SWIG_fail;
7275 temp2 = true;
7276 }
7277 {
7278 PyThreadState* __tstate = wxPyBeginAllowThreads();
7279 (arg1)->AddFileToHistory((wxString const &)*arg2);
7280
7281 wxPyEndAllowThreads(__tstate);
7282 if (PyErr_Occurred()) SWIG_fail;
7283 }
7284 Py_INCREF(Py_None); resultobj = Py_None;
7285 {
7286 if (temp2)
7287 delete arg2;
7288 }
7289 return resultobj;
7290 fail:
7291 {
7292 if (temp2)
7293 delete arg2;
7294 }
7295 return NULL;
7296 }
7297
7298
7299 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7300 PyObject *resultobj;
7301 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7302 int arg2 ;
7303 PyObject * obj0 = 0 ;
7304 PyObject * obj1 = 0 ;
7305 char *kwnames[] = {
7306 (char *) "self",(char *) "i", NULL
7307 };
7308
7309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7311 if (SWIG_arg_fail(1)) SWIG_fail;
7312 {
7313 arg2 = (int)(SWIG_As_int(obj1));
7314 if (SWIG_arg_fail(2)) SWIG_fail;
7315 }
7316 {
7317 PyThreadState* __tstate = wxPyBeginAllowThreads();
7318 (arg1)->RemoveFileFromHistory(arg2);
7319
7320 wxPyEndAllowThreads(__tstate);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 Py_INCREF(Py_None); resultobj = Py_None;
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj;
7332 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7333 int result;
7334 PyObject * obj0 = 0 ;
7335 char *kwnames[] = {
7336 (char *) "self", NULL
7337 };
7338
7339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7341 if (SWIG_arg_fail(1)) SWIG_fail;
7342 {
7343 PyThreadState* __tstate = wxPyBeginAllowThreads();
7344 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7345
7346 wxPyEndAllowThreads(__tstate);
7347 if (PyErr_Occurred()) SWIG_fail;
7348 }
7349 {
7350 resultobj = SWIG_From_int((int)(result));
7351 }
7352 return resultobj;
7353 fail:
7354 return NULL;
7355 }
7356
7357
7358 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7359 PyObject *resultobj;
7360 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7361 wxMenu *arg2 = (wxMenu *) 0 ;
7362 PyObject * obj0 = 0 ;
7363 PyObject * obj1 = 0 ;
7364 char *kwnames[] = {
7365 (char *) "self",(char *) "menu", NULL
7366 };
7367
7368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7370 if (SWIG_arg_fail(1)) SWIG_fail;
7371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7372 if (SWIG_arg_fail(2)) SWIG_fail;
7373 {
7374 PyThreadState* __tstate = wxPyBeginAllowThreads();
7375 (arg1)->UseMenu(arg2);
7376
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj;
7389 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7390 wxMenu *arg2 = (wxMenu *) 0 ;
7391 PyObject * obj0 = 0 ;
7392 PyObject * obj1 = 0 ;
7393 char *kwnames[] = {
7394 (char *) "self",(char *) "menu", NULL
7395 };
7396
7397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7399 if (SWIG_arg_fail(1)) SWIG_fail;
7400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7401 if (SWIG_arg_fail(2)) SWIG_fail;
7402 {
7403 PyThreadState* __tstate = wxPyBeginAllowThreads();
7404 (arg1)->RemoveMenu(arg2);
7405
7406 wxPyEndAllowThreads(__tstate);
7407 if (PyErr_Occurred()) SWIG_fail;
7408 }
7409 Py_INCREF(Py_None); resultobj = Py_None;
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7417 PyObject *resultobj;
7418 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7419 wxConfigBase *arg2 = 0 ;
7420 PyObject * obj0 = 0 ;
7421 PyObject * obj1 = 0 ;
7422 char *kwnames[] = {
7423 (char *) "self",(char *) "config", NULL
7424 };
7425
7426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7428 if (SWIG_arg_fail(1)) SWIG_fail;
7429 {
7430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7431 if (SWIG_arg_fail(2)) SWIG_fail;
7432 if (arg2 == NULL) {
7433 SWIG_null_ref("wxConfigBase");
7434 }
7435 if (SWIG_arg_fail(2)) SWIG_fail;
7436 }
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 (arg1)->Load(*arg2);
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 Py_INCREF(Py_None); resultobj = Py_None;
7445 return resultobj;
7446 fail:
7447 return NULL;
7448 }
7449
7450
7451 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7452 PyObject *resultobj;
7453 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7454 wxConfigBase *arg2 = 0 ;
7455 PyObject * obj0 = 0 ;
7456 PyObject * obj1 = 0 ;
7457 char *kwnames[] = {
7458 (char *) "self",(char *) "config", NULL
7459 };
7460
7461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7463 if (SWIG_arg_fail(1)) SWIG_fail;
7464 {
7465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7466 if (SWIG_arg_fail(2)) SWIG_fail;
7467 if (arg2 == NULL) {
7468 SWIG_null_ref("wxConfigBase");
7469 }
7470 if (SWIG_arg_fail(2)) SWIG_fail;
7471 }
7472 {
7473 PyThreadState* __tstate = wxPyBeginAllowThreads();
7474 (arg1)->Save(*arg2);
7475
7476 wxPyEndAllowThreads(__tstate);
7477 if (PyErr_Occurred()) SWIG_fail;
7478 }
7479 Py_INCREF(Py_None); resultobj = Py_None;
7480 return resultobj;
7481 fail:
7482 return NULL;
7483 }
7484
7485
7486 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7487 PyObject *resultobj;
7488 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7489 PyObject * obj0 = 0 ;
7490 char *kwnames[] = {
7491 (char *) "self", NULL
7492 };
7493
7494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7496 if (SWIG_arg_fail(1)) SWIG_fail;
7497 {
7498 PyThreadState* __tstate = wxPyBeginAllowThreads();
7499 (arg1)->AddFilesToMenu();
7500
7501 wxPyEndAllowThreads(__tstate);
7502 if (PyErr_Occurred()) SWIG_fail;
7503 }
7504 Py_INCREF(Py_None); resultobj = Py_None;
7505 return resultobj;
7506 fail:
7507 return NULL;
7508 }
7509
7510
7511 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7512 PyObject *resultobj;
7513 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7514 wxMenu *arg2 = (wxMenu *) 0 ;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "self",(char *) "menu", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7523 if (SWIG_arg_fail(1)) SWIG_fail;
7524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7525 if (SWIG_arg_fail(2)) SWIG_fail;
7526 {
7527 PyThreadState* __tstate = wxPyBeginAllowThreads();
7528 (arg1)->AddFilesToMenu(arg2);
7529
7530 wxPyEndAllowThreads(__tstate);
7531 if (PyErr_Occurred()) SWIG_fail;
7532 }
7533 Py_INCREF(Py_None); resultobj = Py_None;
7534 return resultobj;
7535 fail:
7536 return NULL;
7537 }
7538
7539
7540 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7541 PyObject *resultobj;
7542 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7543 int arg2 ;
7544 wxString result;
7545 PyObject * obj0 = 0 ;
7546 PyObject * obj1 = 0 ;
7547 char *kwnames[] = {
7548 (char *) "self",(char *) "i", NULL
7549 };
7550
7551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7553 if (SWIG_arg_fail(1)) SWIG_fail;
7554 {
7555 arg2 = (int)(SWIG_As_int(obj1));
7556 if (SWIG_arg_fail(2)) SWIG_fail;
7557 }
7558 {
7559 PyThreadState* __tstate = wxPyBeginAllowThreads();
7560 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7561
7562 wxPyEndAllowThreads(__tstate);
7563 if (PyErr_Occurred()) SWIG_fail;
7564 }
7565 {
7566 #if wxUSE_UNICODE
7567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7568 #else
7569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7570 #endif
7571 }
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj;
7580 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7581 int result;
7582 PyObject * obj0 = 0 ;
7583 char *kwnames[] = {
7584 (char *) "self", NULL
7585 };
7586
7587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7589 if (SWIG_arg_fail(1)) SWIG_fail;
7590 {
7591 PyThreadState* __tstate = wxPyBeginAllowThreads();
7592 result = (int)((wxFileHistory const *)arg1)->GetCount();
7593
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = SWIG_From_int((int)(result));
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7607 PyObject *obj;
7608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7609 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7610 Py_INCREF(obj);
7611 return Py_BuildValue((char *)"");
7612 }
7613 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj;
7615 wxString *arg1 = 0 ;
7616 wxString const &arg2_defvalue = wxPyEmptyString ;
7617 wxString *arg2 = (wxString *) &arg2_defvalue ;
7618 wxSingleInstanceChecker *result;
7619 bool temp1 = false ;
7620 bool temp2 = false ;
7621 PyObject * obj0 = 0 ;
7622 PyObject * obj1 = 0 ;
7623 char *kwnames[] = {
7624 (char *) "name",(char *) "path", NULL
7625 };
7626
7627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7628 {
7629 arg1 = wxString_in_helper(obj0);
7630 if (arg1 == NULL) SWIG_fail;
7631 temp1 = true;
7632 }
7633 if (obj1) {
7634 {
7635 arg2 = wxString_in_helper(obj1);
7636 if (arg2 == NULL) SWIG_fail;
7637 temp2 = true;
7638 }
7639 }
7640 {
7641 PyThreadState* __tstate = wxPyBeginAllowThreads();
7642 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7643
7644 wxPyEndAllowThreads(__tstate);
7645 if (PyErr_Occurred()) SWIG_fail;
7646 }
7647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7648 {
7649 if (temp1)
7650 delete arg1;
7651 }
7652 {
7653 if (temp2)
7654 delete arg2;
7655 }
7656 return resultobj;
7657 fail:
7658 {
7659 if (temp1)
7660 delete arg1;
7661 }
7662 {
7663 if (temp2)
7664 delete arg2;
7665 }
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj;
7672 wxSingleInstanceChecker *result;
7673 char *kwnames[] = {
7674 NULL
7675 };
7676
7677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7681
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7686 return resultobj;
7687 fail:
7688 return NULL;
7689 }
7690
7691
7692 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7693 PyObject *resultobj;
7694 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7695 PyObject * obj0 = 0 ;
7696 char *kwnames[] = {
7697 (char *) "self", NULL
7698 };
7699
7700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7702 if (SWIG_arg_fail(1)) SWIG_fail;
7703 {
7704 PyThreadState* __tstate = wxPyBeginAllowThreads();
7705 delete arg1;
7706
7707 wxPyEndAllowThreads(__tstate);
7708 if (PyErr_Occurred()) SWIG_fail;
7709 }
7710 Py_INCREF(Py_None); resultobj = Py_None;
7711 return resultobj;
7712 fail:
7713 return NULL;
7714 }
7715
7716
7717 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7718 PyObject *resultobj;
7719 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7720 wxString *arg2 = 0 ;
7721 wxString const &arg3_defvalue = wxPyEmptyString ;
7722 wxString *arg3 = (wxString *) &arg3_defvalue ;
7723 bool result;
7724 bool temp2 = false ;
7725 bool temp3 = false ;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 PyObject * obj2 = 0 ;
7729 char *kwnames[] = {
7730 (char *) "self",(char *) "name",(char *) "path", NULL
7731 };
7732
7733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7735 if (SWIG_arg_fail(1)) SWIG_fail;
7736 {
7737 arg2 = wxString_in_helper(obj1);
7738 if (arg2 == NULL) SWIG_fail;
7739 temp2 = true;
7740 }
7741 if (obj2) {
7742 {
7743 arg3 = wxString_in_helper(obj2);
7744 if (arg3 == NULL) SWIG_fail;
7745 temp3 = true;
7746 }
7747 }
7748 {
7749 PyThreadState* __tstate = wxPyBeginAllowThreads();
7750 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7751
7752 wxPyEndAllowThreads(__tstate);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7757 }
7758 {
7759 if (temp2)
7760 delete arg2;
7761 }
7762 {
7763 if (temp3)
7764 delete arg3;
7765 }
7766 return resultobj;
7767 fail:
7768 {
7769 if (temp2)
7770 delete arg2;
7771 }
7772 {
7773 if (temp3)
7774 delete arg3;
7775 }
7776 return NULL;
7777 }
7778
7779
7780 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj;
7782 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7783 bool result;
7784 PyObject * obj0 = 0 ;
7785 char *kwnames[] = {
7786 (char *) "self", NULL
7787 };
7788
7789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7809 PyObject *obj;
7810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7811 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7812 Py_INCREF(obj);
7813 return Py_BuildValue((char *)"");
7814 }
7815 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7816 PyObject *resultobj;
7817 wxWindow *arg1 = (wxWindow *) 0 ;
7818 wxDC *arg2 = 0 ;
7819 bool result;
7820 PyObject * obj0 = 0 ;
7821 PyObject * obj1 = 0 ;
7822 char *kwnames[] = {
7823 (char *) "window",(char *) "dc", NULL
7824 };
7825
7826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7828 if (SWIG_arg_fail(1)) SWIG_fail;
7829 {
7830 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(2)) SWIG_fail;
7832 if (arg2 == NULL) {
7833 SWIG_null_ref("wxDC");
7834 }
7835 if (SWIG_arg_fail(2)) SWIG_fail;
7836 }
7837 {
7838 PyThreadState* __tstate = wxPyBeginAllowThreads();
7839 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7840
7841 wxPyEndAllowThreads(__tstate);
7842 if (PyErr_Occurred()) SWIG_fail;
7843 }
7844 {
7845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7846 }
7847 return resultobj;
7848 fail:
7849 return NULL;
7850 }
7851
7852
7853 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7854 PyObject *resultobj;
7855 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7856 PyObject * obj0 = 0 ;
7857 char *kwnames[] = {
7858 (char *) "self", NULL
7859 };
7860
7861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7863 if (SWIG_arg_fail(1)) SWIG_fail;
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 delete arg1;
7867
7868 wxPyEndAllowThreads(__tstate);
7869 if (PyErr_Occurred()) SWIG_fail;
7870 }
7871 Py_INCREF(Py_None); resultobj = Py_None;
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj;
7880 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7881 wxString result;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (arg1)->GetTip();
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 {
7898 #if wxUSE_UNICODE
7899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7900 #else
7901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7902 #endif
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj;
7912 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7913 size_t result;
7914 PyObject * obj0 = 0 ;
7915 char *kwnames[] = {
7916 (char *) "self", NULL
7917 };
7918
7919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7921 if (SWIG_arg_fail(1)) SWIG_fail;
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 result = (size_t)(arg1)->GetCurrentTip();
7925
7926 wxPyEndAllowThreads(__tstate);
7927 if (PyErr_Occurred()) SWIG_fail;
7928 }
7929 {
7930 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7931 }
7932 return resultobj;
7933 fail:
7934 return NULL;
7935 }
7936
7937
7938 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7939 PyObject *resultobj;
7940 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7941 wxString *arg2 = 0 ;
7942 wxString result;
7943 bool temp2 = false ;
7944 PyObject * obj0 = 0 ;
7945 PyObject * obj1 = 0 ;
7946 char *kwnames[] = {
7947 (char *) "self",(char *) "tip", NULL
7948 };
7949
7950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7952 if (SWIG_arg_fail(1)) SWIG_fail;
7953 {
7954 arg2 = wxString_in_helper(obj1);
7955 if (arg2 == NULL) SWIG_fail;
7956 temp2 = true;
7957 }
7958 {
7959 PyThreadState* __tstate = wxPyBeginAllowThreads();
7960 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7961
7962 wxPyEndAllowThreads(__tstate);
7963 if (PyErr_Occurred()) SWIG_fail;
7964 }
7965 {
7966 #if wxUSE_UNICODE
7967 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7968 #else
7969 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7970 #endif
7971 }
7972 {
7973 if (temp2)
7974 delete arg2;
7975 }
7976 return resultobj;
7977 fail:
7978 {
7979 if (temp2)
7980 delete arg2;
7981 }
7982 return NULL;
7983 }
7984
7985
7986 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7987 PyObject *obj;
7988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7989 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7990 Py_INCREF(obj);
7991 return Py_BuildValue((char *)"");
7992 }
7993 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7994 PyObject *resultobj;
7995 size_t arg1 ;
7996 wxPyTipProvider *result;
7997 PyObject * obj0 = 0 ;
7998 char *kwnames[] = {
7999 (char *) "currentTip", NULL
8000 };
8001
8002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8003 {
8004 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8005 if (SWIG_arg_fail(1)) SWIG_fail;
8006 }
8007 {
8008 PyThreadState* __tstate = wxPyBeginAllowThreads();
8009 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8010
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8022 PyObject *resultobj;
8023 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8024 PyObject *arg2 = (PyObject *) 0 ;
8025 PyObject *arg3 = (PyObject *) 0 ;
8026 PyObject * obj0 = 0 ;
8027 PyObject * obj1 = 0 ;
8028 PyObject * obj2 = 0 ;
8029 char *kwnames[] = {
8030 (char *) "self",(char *) "self",(char *) "_class", NULL
8031 };
8032
8033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8035 if (SWIG_arg_fail(1)) SWIG_fail;
8036 arg2 = obj1;
8037 arg3 = obj2;
8038 {
8039 PyThreadState* __tstate = wxPyBeginAllowThreads();
8040 (arg1)->_setCallbackInfo(arg2,arg3);
8041
8042 wxPyEndAllowThreads(__tstate);
8043 if (PyErr_Occurred()) SWIG_fail;
8044 }
8045 Py_INCREF(Py_None); resultobj = Py_None;
8046 return resultobj;
8047 fail:
8048 return NULL;
8049 }
8050
8051
8052 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8053 PyObject *obj;
8054 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8055 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8056 Py_INCREF(obj);
8057 return Py_BuildValue((char *)"");
8058 }
8059 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj;
8061 wxWindow *arg1 = (wxWindow *) 0 ;
8062 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8063 bool arg3 = (bool) true ;
8064 bool result;
8065 PyObject * obj0 = 0 ;
8066 PyObject * obj1 = 0 ;
8067 PyObject * obj2 = 0 ;
8068 char *kwnames[] = {
8069 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8070 };
8071
8072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8074 if (SWIG_arg_fail(1)) SWIG_fail;
8075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8076 if (SWIG_arg_fail(2)) SWIG_fail;
8077 if (obj2) {
8078 {
8079 arg3 = (bool)(SWIG_As_bool(obj2));
8080 if (SWIG_arg_fail(3)) SWIG_fail;
8081 }
8082 }
8083 {
8084 if (!wxPyCheckForApp()) SWIG_fail;
8085 PyThreadState* __tstate = wxPyBeginAllowThreads();
8086 result = (bool)wxShowTip(arg1,arg2,arg3);
8087
8088 wxPyEndAllowThreads(__tstate);
8089 if (PyErr_Occurred()) SWIG_fail;
8090 }
8091 {
8092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8093 }
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj;
8102 wxString *arg1 = 0 ;
8103 size_t arg2 ;
8104 wxTipProvider *result;
8105 bool temp1 = false ;
8106 PyObject * obj0 = 0 ;
8107 PyObject * obj1 = 0 ;
8108 char *kwnames[] = {
8109 (char *) "filename",(char *) "currentTip", NULL
8110 };
8111
8112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8113 {
8114 arg1 = wxString_in_helper(obj0);
8115 if (arg1 == NULL) SWIG_fail;
8116 temp1 = true;
8117 }
8118 {
8119 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8120 if (SWIG_arg_fail(2)) SWIG_fail;
8121 }
8122 {
8123 if (!wxPyCheckForApp()) SWIG_fail;
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8126
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8131 {
8132 if (temp1)
8133 delete arg1;
8134 }
8135 return resultobj;
8136 fail:
8137 {
8138 if (temp1)
8139 delete arg1;
8140 }
8141 return NULL;
8142 }
8143
8144
8145 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj;
8147 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8148 int arg2 = (int) -1 ;
8149 wxPyTimer *result;
8150 PyObject * obj0 = 0 ;
8151 PyObject * obj1 = 0 ;
8152 char *kwnames[] = {
8153 (char *) "owner",(char *) "id", NULL
8154 };
8155
8156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8157 if (obj0) {
8158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8159 if (SWIG_arg_fail(1)) SWIG_fail;
8160 }
8161 if (obj1) {
8162 {
8163 arg2 = (int)(SWIG_As_int(obj1));
8164 if (SWIG_arg_fail(2)) SWIG_fail;
8165 }
8166 }
8167 {
8168 if (!wxPyCheckForApp()) SWIG_fail;
8169 PyThreadState* __tstate = wxPyBeginAllowThreads();
8170 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8171
8172 wxPyEndAllowThreads(__tstate);
8173 if (PyErr_Occurred()) SWIG_fail;
8174 }
8175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8176 return resultobj;
8177 fail:
8178 return NULL;
8179 }
8180
8181
8182 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8183 PyObject *resultobj;
8184 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8185 PyObject * obj0 = 0 ;
8186 char *kwnames[] = {
8187 (char *) "self", NULL
8188 };
8189
8190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8192 if (SWIG_arg_fail(1)) SWIG_fail;
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 delete arg1;
8196
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 Py_INCREF(Py_None); resultobj = Py_None;
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8210 PyObject *arg2 = (PyObject *) 0 ;
8211 PyObject *arg3 = (PyObject *) 0 ;
8212 int arg4 = (int) 1 ;
8213 PyObject * obj0 = 0 ;
8214 PyObject * obj1 = 0 ;
8215 PyObject * obj2 = 0 ;
8216 PyObject * obj3 = 0 ;
8217 char *kwnames[] = {
8218 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8219 };
8220
8221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8223 if (SWIG_arg_fail(1)) SWIG_fail;
8224 arg2 = obj1;
8225 arg3 = obj2;
8226 if (obj3) {
8227 {
8228 arg4 = (int)(SWIG_As_int(obj3));
8229 if (SWIG_arg_fail(4)) SWIG_fail;
8230 }
8231 }
8232 {
8233 PyThreadState* __tstate = wxPyBeginAllowThreads();
8234 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8235
8236 wxPyEndAllowThreads(__tstate);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 Py_INCREF(Py_None); resultobj = Py_None;
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj;
8248 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8249 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8250 int arg3 = (int) -1 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 PyObject * obj2 = 0 ;
8254 char *kwnames[] = {
8255 (char *) "self",(char *) "owner",(char *) "id", NULL
8256 };
8257
8258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8260 if (SWIG_arg_fail(1)) SWIG_fail;
8261 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8262 if (SWIG_arg_fail(2)) SWIG_fail;
8263 if (obj2) {
8264 {
8265 arg3 = (int)(SWIG_As_int(obj2));
8266 if (SWIG_arg_fail(3)) SWIG_fail;
8267 }
8268 }
8269 {
8270 PyThreadState* __tstate = wxPyBeginAllowThreads();
8271 (arg1)->SetOwner(arg2,arg3);
8272
8273 wxPyEndAllowThreads(__tstate);
8274 if (PyErr_Occurred()) SWIG_fail;
8275 }
8276 Py_INCREF(Py_None); resultobj = Py_None;
8277 return resultobj;
8278 fail:
8279 return NULL;
8280 }
8281
8282
8283 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8284 PyObject *resultobj;
8285 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8286 wxEvtHandler *result;
8287 PyObject * obj0 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 result = (wxEvtHandler *)(arg1)->GetOwner();
8298
8299 wxPyEndAllowThreads(__tstate);
8300 if (PyErr_Occurred()) SWIG_fail;
8301 }
8302 {
8303 resultobj = wxPyMake_wxObject(result, 0);
8304 }
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8314 int arg2 = (int) -1 ;
8315 bool arg3 = (bool) false ;
8316 bool result;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 PyObject * obj2 = 0 ;
8320 char *kwnames[] = {
8321 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8322 };
8323
8324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8326 if (SWIG_arg_fail(1)) SWIG_fail;
8327 if (obj1) {
8328 {
8329 arg2 = (int)(SWIG_As_int(obj1));
8330 if (SWIG_arg_fail(2)) SWIG_fail;
8331 }
8332 }
8333 if (obj2) {
8334 {
8335 arg3 = (bool)(SWIG_As_bool(obj2));
8336 if (SWIG_arg_fail(3)) SWIG_fail;
8337 }
8338 }
8339 {
8340 PyThreadState* __tstate = wxPyBeginAllowThreads();
8341 result = (bool)(arg1)->Start(arg2,arg3);
8342
8343 wxPyEndAllowThreads(__tstate);
8344 if (PyErr_Occurred()) SWIG_fail;
8345 }
8346 {
8347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8348 }
8349 return resultobj;
8350 fail:
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8358 PyObject * obj0 = 0 ;
8359 char *kwnames[] = {
8360 (char *) "self", NULL
8361 };
8362
8363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8365 if (SWIG_arg_fail(1)) SWIG_fail;
8366 {
8367 PyThreadState* __tstate = wxPyBeginAllowThreads();
8368 (arg1)->Stop();
8369
8370 wxPyEndAllowThreads(__tstate);
8371 if (PyErr_Occurred()) SWIG_fail;
8372 }
8373 Py_INCREF(Py_None); resultobj = Py_None;
8374 return resultobj;
8375 fail:
8376 return NULL;
8377 }
8378
8379
8380 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8381 PyObject *resultobj;
8382 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8383 bool result;
8384 PyObject * obj0 = 0 ;
8385 char *kwnames[] = {
8386 (char *) "self", NULL
8387 };
8388
8389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8391 if (SWIG_arg_fail(1)) SWIG_fail;
8392 {
8393 PyThreadState* __tstate = wxPyBeginAllowThreads();
8394 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8395
8396 wxPyEndAllowThreads(__tstate);
8397 if (PyErr_Occurred()) SWIG_fail;
8398 }
8399 {
8400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8401 }
8402 return resultobj;
8403 fail:
8404 return NULL;
8405 }
8406
8407
8408 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8409 PyObject *resultobj;
8410 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8411 int result;
8412 PyObject * obj0 = 0 ;
8413 char *kwnames[] = {
8414 (char *) "self", NULL
8415 };
8416
8417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8419 if (SWIG_arg_fail(1)) SWIG_fail;
8420 {
8421 PyThreadState* __tstate = wxPyBeginAllowThreads();
8422 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8423
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 {
8428 resultobj = SWIG_From_int((int)(result));
8429 }
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj;
8438 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8439 bool result;
8440 PyObject * obj0 = 0 ;
8441 char *kwnames[] = {
8442 (char *) "self", NULL
8443 };
8444
8445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8447 if (SWIG_arg_fail(1)) SWIG_fail;
8448 {
8449 PyThreadState* __tstate = wxPyBeginAllowThreads();
8450 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8451
8452 wxPyEndAllowThreads(__tstate);
8453 if (PyErr_Occurred()) SWIG_fail;
8454 }
8455 {
8456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8457 }
8458 return resultobj;
8459 fail:
8460 return NULL;
8461 }
8462
8463
8464 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8465 PyObject *resultobj;
8466 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8467 int result;
8468 PyObject * obj0 = 0 ;
8469 char *kwnames[] = {
8470 (char *) "self", NULL
8471 };
8472
8473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8475 if (SWIG_arg_fail(1)) SWIG_fail;
8476 {
8477 PyThreadState* __tstate = wxPyBeginAllowThreads();
8478 result = (int)((wxPyTimer const *)arg1)->GetId();
8479
8480 wxPyEndAllowThreads(__tstate);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 {
8484 resultobj = SWIG_From_int((int)(result));
8485 }
8486 return resultobj;
8487 fail:
8488 return NULL;
8489 }
8490
8491
8492 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8493 PyObject *obj;
8494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8495 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8496 Py_INCREF(obj);
8497 return Py_BuildValue((char *)"");
8498 }
8499 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8500 PyObject *resultobj;
8501 int arg1 = (int) 0 ;
8502 int arg2 = (int) 0 ;
8503 wxTimerEvent *result;
8504 PyObject * obj0 = 0 ;
8505 PyObject * obj1 = 0 ;
8506 char *kwnames[] = {
8507 (char *) "timerid",(char *) "interval", NULL
8508 };
8509
8510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8511 if (obj0) {
8512 {
8513 arg1 = (int)(SWIG_As_int(obj0));
8514 if (SWIG_arg_fail(1)) SWIG_fail;
8515 }
8516 }
8517 if (obj1) {
8518 {
8519 arg2 = (int)(SWIG_As_int(obj1));
8520 if (SWIG_arg_fail(2)) SWIG_fail;
8521 }
8522 }
8523 {
8524 PyThreadState* __tstate = wxPyBeginAllowThreads();
8525 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8526
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj;
8539 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8540 int result;
8541 PyObject * obj0 = 0 ;
8542 char *kwnames[] = {
8543 (char *) "self", NULL
8544 };
8545
8546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8548 if (SWIG_arg_fail(1)) SWIG_fail;
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 {
8557 resultobj = SWIG_From_int((int)(result));
8558 }
8559 return resultobj;
8560 fail:
8561 return NULL;
8562 }
8563
8564
8565 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8566 PyObject *obj;
8567 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8568 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8569 Py_INCREF(obj);
8570 return Py_BuildValue((char *)"");
8571 }
8572 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8573 PyObject *resultobj;
8574 wxTimer *arg1 = 0 ;
8575 wxTimerRunner *result;
8576 PyObject * obj0 = 0 ;
8577
8578 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8579 {
8580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8581 if (SWIG_arg_fail(1)) SWIG_fail;
8582 if (arg1 == NULL) {
8583 SWIG_null_ref("wxTimer");
8584 }
8585 if (SWIG_arg_fail(1)) SWIG_fail;
8586 }
8587 {
8588 if (!wxPyCheckForApp()) SWIG_fail;
8589 PyThreadState* __tstate = wxPyBeginAllowThreads();
8590 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8591
8592 wxPyEndAllowThreads(__tstate);
8593 if (PyErr_Occurred()) SWIG_fail;
8594 }
8595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8596 return resultobj;
8597 fail:
8598 return NULL;
8599 }
8600
8601
8602 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8603 PyObject *resultobj;
8604 wxTimer *arg1 = 0 ;
8605 int arg2 ;
8606 bool arg3 = (bool) false ;
8607 wxTimerRunner *result;
8608 PyObject * obj0 = 0 ;
8609 PyObject * obj1 = 0 ;
8610 PyObject * obj2 = 0 ;
8611
8612 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8613 {
8614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8615 if (SWIG_arg_fail(1)) SWIG_fail;
8616 if (arg1 == NULL) {
8617 SWIG_null_ref("wxTimer");
8618 }
8619 if (SWIG_arg_fail(1)) SWIG_fail;
8620 }
8621 {
8622 arg2 = (int)(SWIG_As_int(obj1));
8623 if (SWIG_arg_fail(2)) SWIG_fail;
8624 }
8625 if (obj2) {
8626 {
8627 arg3 = (bool)(SWIG_As_bool(obj2));
8628 if (SWIG_arg_fail(3)) SWIG_fail;
8629 }
8630 }
8631 {
8632 if (!wxPyCheckForApp()) SWIG_fail;
8633 PyThreadState* __tstate = wxPyBeginAllowThreads();
8634 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8635
8636 wxPyEndAllowThreads(__tstate);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8647 int argc;
8648 PyObject *argv[4];
8649 int ii;
8650
8651 argc = PyObject_Length(args);
8652 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8653 argv[ii] = PyTuple_GetItem(args,ii);
8654 }
8655 if (argc == 1) {
8656 int _v;
8657 {
8658 void *ptr = 0;
8659 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8660 _v = 0;
8661 PyErr_Clear();
8662 } else {
8663 _v = (ptr != 0);
8664 }
8665 }
8666 if (_v) {
8667 return _wrap_new_TimerRunner__SWIG_0(self,args);
8668 }
8669 }
8670 if ((argc >= 2) && (argc <= 3)) {
8671 int _v;
8672 {
8673 void *ptr = 0;
8674 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8675 _v = 0;
8676 PyErr_Clear();
8677 } else {
8678 _v = (ptr != 0);
8679 }
8680 }
8681 if (_v) {
8682 _v = SWIG_Check_int(argv[1]);
8683 if (_v) {
8684 if (argc <= 2) {
8685 return _wrap_new_TimerRunner__SWIG_1(self,args);
8686 }
8687 _v = SWIG_Check_bool(argv[2]);
8688 if (_v) {
8689 return _wrap_new_TimerRunner__SWIG_1(self,args);
8690 }
8691 }
8692 }
8693 }
8694
8695 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8696 return NULL;
8697 }
8698
8699
8700 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8701 PyObject *resultobj;
8702 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8703 PyObject * obj0 = 0 ;
8704 char *kwnames[] = {
8705 (char *) "self", NULL
8706 };
8707
8708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8710 if (SWIG_arg_fail(1)) SWIG_fail;
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 delete arg1;
8714
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 Py_INCREF(Py_None); resultobj = Py_None;
8719 return resultobj;
8720 fail:
8721 return NULL;
8722 }
8723
8724
8725 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8726 PyObject *resultobj;
8727 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8728 int arg2 ;
8729 bool arg3 = (bool) false ;
8730 PyObject * obj0 = 0 ;
8731 PyObject * obj1 = 0 ;
8732 PyObject * obj2 = 0 ;
8733 char *kwnames[] = {
8734 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8735 };
8736
8737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8739 if (SWIG_arg_fail(1)) SWIG_fail;
8740 {
8741 arg2 = (int)(SWIG_As_int(obj1));
8742 if (SWIG_arg_fail(2)) SWIG_fail;
8743 }
8744 if (obj2) {
8745 {
8746 arg3 = (bool)(SWIG_As_bool(obj2));
8747 if (SWIG_arg_fail(3)) SWIG_fail;
8748 }
8749 }
8750 {
8751 PyThreadState* __tstate = wxPyBeginAllowThreads();
8752 (arg1)->Start(arg2,arg3);
8753
8754 wxPyEndAllowThreads(__tstate);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 Py_INCREF(Py_None); resultobj = Py_None;
8758 return resultobj;
8759 fail:
8760 return NULL;
8761 }
8762
8763
8764 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8765 PyObject *obj;
8766 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8767 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8768 Py_INCREF(obj);
8769 return Py_BuildValue((char *)"");
8770 }
8771 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8772 PyObject *resultobj;
8773 wxLog *result;
8774 char *kwnames[] = {
8775 NULL
8776 };
8777
8778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 result = (wxLog *)new wxLog();
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 bool result;
8796 char *kwnames[] = {
8797 NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8801 {
8802 PyThreadState* __tstate = wxPyBeginAllowThreads();
8803 result = (bool)wxLog::IsEnabled();
8804
8805 wxPyEndAllowThreads(__tstate);
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 {
8809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8810 }
8811 return resultobj;
8812 fail:
8813 return NULL;
8814 }
8815
8816
8817 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8818 PyObject *resultobj;
8819 bool arg1 = (bool) true ;
8820 bool result;
8821 PyObject * obj0 = 0 ;
8822 char *kwnames[] = {
8823 (char *) "doIt", NULL
8824 };
8825
8826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8827 if (obj0) {
8828 {
8829 arg1 = (bool)(SWIG_As_bool(obj0));
8830 if (SWIG_arg_fail(1)) SWIG_fail;
8831 }
8832 }
8833 {
8834 PyThreadState* __tstate = wxPyBeginAllowThreads();
8835 result = (bool)wxLog::EnableLogging(arg1);
8836
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 {
8841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8842 }
8843 return resultobj;
8844 fail:
8845 return NULL;
8846 }
8847
8848
8849 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8850 PyObject *resultobj;
8851 wxLogLevel arg1 ;
8852 wxChar *arg2 = (wxChar *) 0 ;
8853 time_t arg3 ;
8854 PyObject * obj0 = 0 ;
8855 PyObject * obj1 = 0 ;
8856 PyObject * obj2 = 0 ;
8857 char *kwnames[] = {
8858 (char *) "level",(char *) "szString",(char *) "t", NULL
8859 };
8860
8861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8862 {
8863 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8864 if (SWIG_arg_fail(1)) SWIG_fail;
8865 }
8866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8867 if (SWIG_arg_fail(2)) SWIG_fail;
8868 {
8869 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8870 if (SWIG_arg_fail(3)) SWIG_fail;
8871 }
8872 {
8873 PyThreadState* __tstate = wxPyBeginAllowThreads();
8874 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8875
8876 wxPyEndAllowThreads(__tstate);
8877 if (PyErr_Occurred()) SWIG_fail;
8878 }
8879 Py_INCREF(Py_None); resultobj = Py_None;
8880 return resultobj;
8881 fail:
8882 return NULL;
8883 }
8884
8885
8886 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8887 PyObject *resultobj;
8888 wxLog *arg1 = (wxLog *) 0 ;
8889 PyObject * obj0 = 0 ;
8890 char *kwnames[] = {
8891 (char *) "self", NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8896 if (SWIG_arg_fail(1)) SWIG_fail;
8897 {
8898 PyThreadState* __tstate = wxPyBeginAllowThreads();
8899 (arg1)->Flush();
8900
8901 wxPyEndAllowThreads(__tstate);
8902 if (PyErr_Occurred()) SWIG_fail;
8903 }
8904 Py_INCREF(Py_None); resultobj = Py_None;
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj;
8913 char *kwnames[] = {
8914 NULL
8915 };
8916
8917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8918 {
8919 PyThreadState* __tstate = wxPyBeginAllowThreads();
8920 wxLog::FlushActive();
8921
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 Py_INCREF(Py_None); resultobj = Py_None;
8926 return resultobj;
8927 fail:
8928 return NULL;
8929 }
8930
8931
8932 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8933 PyObject *resultobj;
8934 wxLog *result;
8935 char *kwnames[] = {
8936 NULL
8937 };
8938
8939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8940 {
8941 PyThreadState* __tstate = wxPyBeginAllowThreads();
8942 result = (wxLog *)wxLog::GetActiveTarget();
8943
8944 wxPyEndAllowThreads(__tstate);
8945 if (PyErr_Occurred()) SWIG_fail;
8946 }
8947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8955 PyObject *resultobj;
8956 wxLog *arg1 = (wxLog *) 0 ;
8957 wxLog *result;
8958 PyObject * obj0 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "pLogger", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 char *kwnames[] = {
8983 NULL
8984 };
8985
8986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 wxLog::Suspend();
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 Py_INCREF(Py_None); resultobj = Py_None;
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj;
9003 char *kwnames[] = {
9004 NULL
9005 };
9006
9007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9008 {
9009 PyThreadState* __tstate = wxPyBeginAllowThreads();
9010 wxLog::Resume();
9011
9012 wxPyEndAllowThreads(__tstate);
9013 if (PyErr_Occurred()) SWIG_fail;
9014 }
9015 Py_INCREF(Py_None); resultobj = Py_None;
9016 return resultobj;
9017 fail:
9018 return NULL;
9019 }
9020
9021
9022 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9023 PyObject *resultobj;
9024 bool arg1 = (bool) true ;
9025 PyObject * obj0 = 0 ;
9026 char *kwnames[] = {
9027 (char *) "bVerbose", NULL
9028 };
9029
9030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9031 if (obj0) {
9032 {
9033 arg1 = (bool)(SWIG_As_bool(obj0));
9034 if (SWIG_arg_fail(1)) SWIG_fail;
9035 }
9036 }
9037 {
9038 PyThreadState* __tstate = wxPyBeginAllowThreads();
9039 wxLog::SetVerbose(arg1);
9040
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 Py_INCREF(Py_None); resultobj = Py_None;
9045 return resultobj;
9046 fail:
9047 return NULL;
9048 }
9049
9050
9051 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9052 PyObject *resultobj;
9053 wxLogLevel arg1 ;
9054 PyObject * obj0 = 0 ;
9055 char *kwnames[] = {
9056 (char *) "logLevel", NULL
9057 };
9058
9059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9060 {
9061 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9062 if (SWIG_arg_fail(1)) SWIG_fail;
9063 }
9064 {
9065 PyThreadState* __tstate = wxPyBeginAllowThreads();
9066 wxLog::SetLogLevel(arg1);
9067
9068 wxPyEndAllowThreads(__tstate);
9069 if (PyErr_Occurred()) SWIG_fail;
9070 }
9071 Py_INCREF(Py_None); resultobj = Py_None;
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9079 PyObject *resultobj;
9080 char *kwnames[] = {
9081 NULL
9082 };
9083
9084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 wxLog::DontCreateOnDemand();
9088
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 Py_INCREF(Py_None); resultobj = Py_None;
9093 return resultobj;
9094 fail:
9095 return NULL;
9096 }
9097
9098
9099 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9100 PyObject *resultobj;
9101 wxTraceMask arg1 ;
9102 PyObject * obj0 = 0 ;
9103 char *kwnames[] = {
9104 (char *) "ulMask", NULL
9105 };
9106
9107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9108 {
9109 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9110 if (SWIG_arg_fail(1)) SWIG_fail;
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 wxLog::SetTraceMask(arg1);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 Py_INCREF(Py_None); resultobj = Py_None;
9120 return resultobj;
9121 fail:
9122 return NULL;
9123 }
9124
9125
9126 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9127 PyObject *resultobj;
9128 wxString *arg1 = 0 ;
9129 bool temp1 = false ;
9130 PyObject * obj0 = 0 ;
9131 char *kwnames[] = {
9132 (char *) "str", NULL
9133 };
9134
9135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9136 {
9137 arg1 = wxString_in_helper(obj0);
9138 if (arg1 == NULL) SWIG_fail;
9139 temp1 = true;
9140 }
9141 {
9142 PyThreadState* __tstate = wxPyBeginAllowThreads();
9143 wxLog::AddTraceMask((wxString const &)*arg1);
9144
9145 wxPyEndAllowThreads(__tstate);
9146 if (PyErr_Occurred()) SWIG_fail;
9147 }
9148 Py_INCREF(Py_None); resultobj = Py_None;
9149 {
9150 if (temp1)
9151 delete arg1;
9152 }
9153 return resultobj;
9154 fail:
9155 {
9156 if (temp1)
9157 delete arg1;
9158 }
9159 return NULL;
9160 }
9161
9162
9163 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9164 PyObject *resultobj;
9165 wxString *arg1 = 0 ;
9166 bool temp1 = false ;
9167 PyObject * obj0 = 0 ;
9168 char *kwnames[] = {
9169 (char *) "str", NULL
9170 };
9171
9172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9173 {
9174 arg1 = wxString_in_helper(obj0);
9175 if (arg1 == NULL) SWIG_fail;
9176 temp1 = true;
9177 }
9178 {
9179 PyThreadState* __tstate = wxPyBeginAllowThreads();
9180 wxLog::RemoveTraceMask((wxString const &)*arg1);
9181
9182 wxPyEndAllowThreads(__tstate);
9183 if (PyErr_Occurred()) SWIG_fail;
9184 }
9185 Py_INCREF(Py_None); resultobj = Py_None;
9186 {
9187 if (temp1)
9188 delete arg1;
9189 }
9190 return resultobj;
9191 fail:
9192 {
9193 if (temp1)
9194 delete arg1;
9195 }
9196 return NULL;
9197 }
9198
9199
9200 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj;
9202 char *kwnames[] = {
9203 NULL
9204 };
9205
9206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 wxLog::ClearTraceMasks();
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 Py_INCREF(Py_None); resultobj = Py_None;
9215 return resultobj;
9216 fail:
9217 return NULL;
9218 }
9219
9220
9221 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9222 PyObject *resultobj;
9223 wxArrayString *result;
9224 char *kwnames[] = {
9225 NULL
9226 };
9227
9228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9229 {
9230 PyThreadState* __tstate = wxPyBeginAllowThreads();
9231 {
9232 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9233 result = (wxArrayString *) &_result_ref;
9234 }
9235
9236 wxPyEndAllowThreads(__tstate);
9237 if (PyErr_Occurred()) SWIG_fail;
9238 }
9239 {
9240 resultobj = wxArrayString2PyList_helper(*result);
9241 }
9242 return resultobj;
9243 fail:
9244 return NULL;
9245 }
9246
9247
9248 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9249 PyObject *resultobj;
9250 wxChar *arg1 = (wxChar *) 0 ;
9251 PyObject * obj0 = 0 ;
9252 char *kwnames[] = {
9253 (char *) "ts", NULL
9254 };
9255
9256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9258 if (SWIG_arg_fail(1)) SWIG_fail;
9259 {
9260 PyThreadState* __tstate = wxPyBeginAllowThreads();
9261 wxLog::SetTimestamp((wxChar const *)arg1);
9262
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 Py_INCREF(Py_None); resultobj = Py_None;
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9274 PyObject *resultobj;
9275 bool result;
9276 char *kwnames[] = {
9277 NULL
9278 };
9279
9280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9281 {
9282 PyThreadState* __tstate = wxPyBeginAllowThreads();
9283 result = (bool)wxLog::GetVerbose();
9284
9285 wxPyEndAllowThreads(__tstate);
9286 if (PyErr_Occurred()) SWIG_fail;
9287 }
9288 {
9289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9290 }
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9298 PyObject *resultobj;
9299 wxTraceMask result;
9300 char *kwnames[] = {
9301 NULL
9302 };
9303
9304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9305 {
9306 PyThreadState* __tstate = wxPyBeginAllowThreads();
9307 result = (wxTraceMask)wxLog::GetTraceMask();
9308
9309 wxPyEndAllowThreads(__tstate);
9310 if (PyErr_Occurred()) SWIG_fail;
9311 }
9312 {
9313 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9314 }
9315 return resultobj;
9316 fail:
9317 return NULL;
9318 }
9319
9320
9321 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9322 PyObject *resultobj;
9323 wxChar *arg1 = (wxChar *) 0 ;
9324 bool result;
9325 PyObject * obj0 = 0 ;
9326 char *kwnames[] = {
9327 (char *) "mask", NULL
9328 };
9329
9330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9332 if (SWIG_arg_fail(1)) SWIG_fail;
9333 {
9334 PyThreadState* __tstate = wxPyBeginAllowThreads();
9335 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9336
9337 wxPyEndAllowThreads(__tstate);
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 {
9341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9342 }
9343 return resultobj;
9344 fail:
9345 return NULL;
9346 }
9347
9348
9349 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9350 PyObject *resultobj;
9351 wxLogLevel result;
9352 char *kwnames[] = {
9353 NULL
9354 };
9355
9356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9357 {
9358 PyThreadState* __tstate = wxPyBeginAllowThreads();
9359 result = (wxLogLevel)wxLog::GetLogLevel();
9360
9361 wxPyEndAllowThreads(__tstate);
9362 if (PyErr_Occurred()) SWIG_fail;
9363 }
9364 {
9365 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9366 }
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9374 PyObject *resultobj;
9375 wxChar *result;
9376 char *kwnames[] = {
9377 NULL
9378 };
9379
9380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (wxChar *)wxLog::GetTimestamp();
9384
9385 wxPyEndAllowThreads(__tstate);
9386 if (PyErr_Occurred()) SWIG_fail;
9387 }
9388 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9389 return resultobj;
9390 fail:
9391 return NULL;
9392 }
9393
9394
9395 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9396 PyObject *resultobj;
9397 wxString result;
9398 char *kwnames[] = {
9399 NULL
9400 };
9401
9402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9403 {
9404 PyThreadState* __tstate = wxPyBeginAllowThreads();
9405 result = Log_TimeStamp();
9406
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 {
9411 #if wxUSE_UNICODE
9412 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9413 #else
9414 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9415 #endif
9416 }
9417 return resultobj;
9418 fail:
9419 return NULL;
9420 }
9421
9422
9423 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9424 PyObject *resultobj;
9425 wxLog *arg1 = (wxLog *) 0 ;
9426 PyObject * obj0 = 0 ;
9427 char *kwnames[] = {
9428 (char *) "self", NULL
9429 };
9430
9431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9433 if (SWIG_arg_fail(1)) SWIG_fail;
9434 {
9435 PyThreadState* __tstate = wxPyBeginAllowThreads();
9436 wxLog_Destroy(arg1);
9437
9438 wxPyEndAllowThreads(__tstate);
9439 if (PyErr_Occurred()) SWIG_fail;
9440 }
9441 Py_INCREF(Py_None); resultobj = Py_None;
9442 return resultobj;
9443 fail:
9444 return NULL;
9445 }
9446
9447
9448 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9449 PyObject *obj;
9450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9451 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9452 Py_INCREF(obj);
9453 return Py_BuildValue((char *)"");
9454 }
9455 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9456 PyObject *resultobj;
9457 wxLogStderr *result;
9458 char *kwnames[] = {
9459 NULL
9460 };
9461
9462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9463 {
9464 PyThreadState* __tstate = wxPyBeginAllowThreads();
9465 result = (wxLogStderr *)new wxLogStderr();
9466
9467 wxPyEndAllowThreads(__tstate);
9468 if (PyErr_Occurred()) SWIG_fail;
9469 }
9470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9471 return resultobj;
9472 fail:
9473 return NULL;
9474 }
9475
9476
9477 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9478 PyObject *obj;
9479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9480 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9481 Py_INCREF(obj);
9482 return Py_BuildValue((char *)"");
9483 }
9484 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9485 PyObject *resultobj;
9486 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9487 wxLogTextCtrl *result;
9488 PyObject * obj0 = 0 ;
9489 char *kwnames[] = {
9490 (char *) "pTextCtrl", NULL
9491 };
9492
9493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9495 if (SWIG_arg_fail(1)) SWIG_fail;
9496 {
9497 PyThreadState* __tstate = wxPyBeginAllowThreads();
9498 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9499
9500 wxPyEndAllowThreads(__tstate);
9501 if (PyErr_Occurred()) SWIG_fail;
9502 }
9503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9504 return resultobj;
9505 fail:
9506 return NULL;
9507 }
9508
9509
9510 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9511 PyObject *obj;
9512 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9513 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9514 Py_INCREF(obj);
9515 return Py_BuildValue((char *)"");
9516 }
9517 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj;
9519 wxLogGui *result;
9520 char *kwnames[] = {
9521 NULL
9522 };
9523
9524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9525 {
9526 PyThreadState* __tstate = wxPyBeginAllowThreads();
9527 result = (wxLogGui *)new wxLogGui();
9528
9529 wxPyEndAllowThreads(__tstate);
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9540 PyObject *obj;
9541 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9542 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9543 Py_INCREF(obj);
9544 return Py_BuildValue((char *)"");
9545 }
9546 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9547 PyObject *resultobj;
9548 wxFrame *arg1 = (wxFrame *) 0 ;
9549 wxString *arg2 = 0 ;
9550 bool arg3 = (bool) true ;
9551 bool arg4 = (bool) true ;
9552 wxLogWindow *result;
9553 bool temp2 = false ;
9554 PyObject * obj0 = 0 ;
9555 PyObject * obj1 = 0 ;
9556 PyObject * obj2 = 0 ;
9557 PyObject * obj3 = 0 ;
9558 char *kwnames[] = {
9559 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9560 };
9561
9562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9564 if (SWIG_arg_fail(1)) SWIG_fail;
9565 {
9566 arg2 = wxString_in_helper(obj1);
9567 if (arg2 == NULL) SWIG_fail;
9568 temp2 = true;
9569 }
9570 if (obj2) {
9571 {
9572 arg3 = (bool)(SWIG_As_bool(obj2));
9573 if (SWIG_arg_fail(3)) SWIG_fail;
9574 }
9575 }
9576 if (obj3) {
9577 {
9578 arg4 = (bool)(SWIG_As_bool(obj3));
9579 if (SWIG_arg_fail(4)) SWIG_fail;
9580 }
9581 }
9582 {
9583 PyThreadState* __tstate = wxPyBeginAllowThreads();
9584 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9585
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9590 {
9591 if (temp2)
9592 delete arg2;
9593 }
9594 return resultobj;
9595 fail:
9596 {
9597 if (temp2)
9598 delete arg2;
9599 }
9600 return NULL;
9601 }
9602
9603
9604 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9605 PyObject *resultobj;
9606 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9607 bool arg2 = (bool) true ;
9608 PyObject * obj0 = 0 ;
9609 PyObject * obj1 = 0 ;
9610 char *kwnames[] = {
9611 (char *) "self",(char *) "bShow", NULL
9612 };
9613
9614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9616 if (SWIG_arg_fail(1)) SWIG_fail;
9617 if (obj1) {
9618 {
9619 arg2 = (bool)(SWIG_As_bool(obj1));
9620 if (SWIG_arg_fail(2)) SWIG_fail;
9621 }
9622 }
9623 {
9624 PyThreadState* __tstate = wxPyBeginAllowThreads();
9625 (arg1)->Show(arg2);
9626
9627 wxPyEndAllowThreads(__tstate);
9628 if (PyErr_Occurred()) SWIG_fail;
9629 }
9630 Py_INCREF(Py_None); resultobj = Py_None;
9631 return resultobj;
9632 fail:
9633 return NULL;
9634 }
9635
9636
9637 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj;
9639 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9640 wxFrame *result;
9641 PyObject * obj0 = 0 ;
9642 char *kwnames[] = {
9643 (char *) "self", NULL
9644 };
9645
9646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9648 if (SWIG_arg_fail(1)) SWIG_fail;
9649 {
9650 PyThreadState* __tstate = wxPyBeginAllowThreads();
9651 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9652
9653 wxPyEndAllowThreads(__tstate);
9654 if (PyErr_Occurred()) SWIG_fail;
9655 }
9656 {
9657 resultobj = wxPyMake_wxObject(result, 0);
9658 }
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9666 PyObject *resultobj;
9667 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9668 wxLog *result;
9669 PyObject * obj0 = 0 ;
9670 char *kwnames[] = {
9671 (char *) "self", NULL
9672 };
9673
9674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9676 if (SWIG_arg_fail(1)) SWIG_fail;
9677 {
9678 PyThreadState* __tstate = wxPyBeginAllowThreads();
9679 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9680
9681 wxPyEndAllowThreads(__tstate);
9682 if (PyErr_Occurred()) SWIG_fail;
9683 }
9684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9685 return resultobj;
9686 fail:
9687 return NULL;
9688 }
9689
9690
9691 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9692 PyObject *resultobj;
9693 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9694 bool result;
9695 PyObject * obj0 = 0 ;
9696 char *kwnames[] = {
9697 (char *) "self", NULL
9698 };
9699
9700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9702 if (SWIG_arg_fail(1)) SWIG_fail;
9703 {
9704 PyThreadState* __tstate = wxPyBeginAllowThreads();
9705 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9706
9707 wxPyEndAllowThreads(__tstate);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 {
9711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9712 }
9713 return resultobj;
9714 fail:
9715 return NULL;
9716 }
9717
9718
9719 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9720 PyObject *resultobj;
9721 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9722 bool arg2 ;
9723 PyObject * obj0 = 0 ;
9724 PyObject * obj1 = 0 ;
9725 char *kwnames[] = {
9726 (char *) "self",(char *) "bDoPass", NULL
9727 };
9728
9729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9731 if (SWIG_arg_fail(1)) SWIG_fail;
9732 {
9733 arg2 = (bool)(SWIG_As_bool(obj1));
9734 if (SWIG_arg_fail(2)) SWIG_fail;
9735 }
9736 {
9737 PyThreadState* __tstate = wxPyBeginAllowThreads();
9738 (arg1)->PassMessages(arg2);
9739
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 Py_INCREF(Py_None); resultobj = Py_None;
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9751 PyObject *obj;
9752 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9753 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9754 Py_INCREF(obj);
9755 return Py_BuildValue((char *)"");
9756 }
9757 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9758 PyObject *resultobj;
9759 wxLog *arg1 = (wxLog *) 0 ;
9760 wxLogChain *result;
9761 PyObject * obj0 = 0 ;
9762 char *kwnames[] = {
9763 (char *) "logger", NULL
9764 };
9765
9766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9768 if (SWIG_arg_fail(1)) SWIG_fail;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (wxLogChain *)new wxLogChain(arg1);
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9777 return resultobj;
9778 fail:
9779 return NULL;
9780 }
9781
9782
9783 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9784 PyObject *resultobj;
9785 wxLogChain *arg1 = (wxLogChain *) 0 ;
9786 wxLog *arg2 = (wxLog *) 0 ;
9787 PyObject * obj0 = 0 ;
9788 PyObject * obj1 = 0 ;
9789 char *kwnames[] = {
9790 (char *) "self",(char *) "logger", NULL
9791 };
9792
9793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9795 if (SWIG_arg_fail(1)) SWIG_fail;
9796 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9797 if (SWIG_arg_fail(2)) SWIG_fail;
9798 {
9799 PyThreadState* __tstate = wxPyBeginAllowThreads();
9800 (arg1)->SetLog(arg2);
9801
9802 wxPyEndAllowThreads(__tstate);
9803 if (PyErr_Occurred()) SWIG_fail;
9804 }
9805 Py_INCREF(Py_None); resultobj = Py_None;
9806 return resultobj;
9807 fail:
9808 return NULL;
9809 }
9810
9811
9812 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9813 PyObject *resultobj;
9814 wxLogChain *arg1 = (wxLogChain *) 0 ;
9815 bool arg2 ;
9816 PyObject * obj0 = 0 ;
9817 PyObject * obj1 = 0 ;
9818 char *kwnames[] = {
9819 (char *) "self",(char *) "bDoPass", NULL
9820 };
9821
9822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9824 if (SWIG_arg_fail(1)) SWIG_fail;
9825 {
9826 arg2 = (bool)(SWIG_As_bool(obj1));
9827 if (SWIG_arg_fail(2)) SWIG_fail;
9828 }
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 (arg1)->PassMessages(arg2);
9832
9833 wxPyEndAllowThreads(__tstate);
9834 if (PyErr_Occurred()) SWIG_fail;
9835 }
9836 Py_INCREF(Py_None); resultobj = Py_None;
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9844 PyObject *resultobj;
9845 wxLogChain *arg1 = (wxLogChain *) 0 ;
9846 bool result;
9847 PyObject * obj0 = 0 ;
9848 char *kwnames[] = {
9849 (char *) "self", NULL
9850 };
9851
9852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9854 if (SWIG_arg_fail(1)) SWIG_fail;
9855 {
9856 PyThreadState* __tstate = wxPyBeginAllowThreads();
9857 result = (bool)(arg1)->IsPassingMessages();
9858
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 {
9863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9864 }
9865 return resultobj;
9866 fail:
9867 return NULL;
9868 }
9869
9870
9871 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxLogChain *arg1 = (wxLogChain *) 0 ;
9874 wxLog *result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (wxLog *)(arg1)->GetOldLog();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9898 PyObject *obj;
9899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9900 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9901 Py_INCREF(obj);
9902 return Py_BuildValue((char *)"");
9903 }
9904 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9905 PyObject *resultobj;
9906 unsigned long result;
9907 char *kwnames[] = {
9908 NULL
9909 };
9910
9911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (unsigned long)wxSysErrorCode();
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 {
9920 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9921 }
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj;
9930 unsigned long arg1 = (unsigned long) 0 ;
9931 wxString result;
9932 PyObject * obj0 = 0 ;
9933 char *kwnames[] = {
9934 (char *) "nErrCode", NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9938 if (obj0) {
9939 {
9940 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9941 if (SWIG_arg_fail(1)) SWIG_fail;
9942 }
9943 }
9944 {
9945 PyThreadState* __tstate = wxPyBeginAllowThreads();
9946 result = wxSysErrorMsg(arg1);
9947
9948 wxPyEndAllowThreads(__tstate);
9949 if (PyErr_Occurred()) SWIG_fail;
9950 }
9951 {
9952 #if wxUSE_UNICODE
9953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9954 #else
9955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9956 #endif
9957 }
9958 return resultobj;
9959 fail:
9960 return NULL;
9961 }
9962
9963
9964 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9965 PyObject *resultobj;
9966 wxString *arg1 = 0 ;
9967 bool temp1 = false ;
9968 PyObject * obj0 = 0 ;
9969 char *kwnames[] = {
9970 (char *) "msg", NULL
9971 };
9972
9973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9974 {
9975 arg1 = wxString_in_helper(obj0);
9976 if (arg1 == NULL) SWIG_fail;
9977 temp1 = true;
9978 }
9979 {
9980 PyThreadState* __tstate = wxPyBeginAllowThreads();
9981 wxPyLogFatalError((wxString const &)*arg1);
9982
9983 wxPyEndAllowThreads(__tstate);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 Py_INCREF(Py_None); resultobj = Py_None;
9987 {
9988 if (temp1)
9989 delete arg1;
9990 }
9991 return resultobj;
9992 fail:
9993 {
9994 if (temp1)
9995 delete arg1;
9996 }
9997 return NULL;
9998 }
9999
10000
10001 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10002 PyObject *resultobj;
10003 wxString *arg1 = 0 ;
10004 bool temp1 = false ;
10005 PyObject * obj0 = 0 ;
10006 char *kwnames[] = {
10007 (char *) "msg", NULL
10008 };
10009
10010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10011 {
10012 arg1 = wxString_in_helper(obj0);
10013 if (arg1 == NULL) SWIG_fail;
10014 temp1 = true;
10015 }
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 wxPyLogError((wxString const &)*arg1);
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 Py_INCREF(Py_None); resultobj = Py_None;
10024 {
10025 if (temp1)
10026 delete arg1;
10027 }
10028 return resultobj;
10029 fail:
10030 {
10031 if (temp1)
10032 delete arg1;
10033 }
10034 return NULL;
10035 }
10036
10037
10038 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10039 PyObject *resultobj;
10040 wxString *arg1 = 0 ;
10041 bool temp1 = false ;
10042 PyObject * obj0 = 0 ;
10043 char *kwnames[] = {
10044 (char *) "msg", NULL
10045 };
10046
10047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10048 {
10049 arg1 = wxString_in_helper(obj0);
10050 if (arg1 == NULL) SWIG_fail;
10051 temp1 = true;
10052 }
10053 {
10054 PyThreadState* __tstate = wxPyBeginAllowThreads();
10055 wxPyLogWarning((wxString const &)*arg1);
10056
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 Py_INCREF(Py_None); resultobj = Py_None;
10061 {
10062 if (temp1)
10063 delete arg1;
10064 }
10065 return resultobj;
10066 fail:
10067 {
10068 if (temp1)
10069 delete arg1;
10070 }
10071 return NULL;
10072 }
10073
10074
10075 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10076 PyObject *resultobj;
10077 wxString *arg1 = 0 ;
10078 bool temp1 = false ;
10079 PyObject * obj0 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "msg", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10085 {
10086 arg1 = wxString_in_helper(obj0);
10087 if (arg1 == NULL) SWIG_fail;
10088 temp1 = true;
10089 }
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 wxPyLogMessage((wxString const &)*arg1);
10093
10094 wxPyEndAllowThreads(__tstate);
10095 if (PyErr_Occurred()) SWIG_fail;
10096 }
10097 Py_INCREF(Py_None); resultobj = Py_None;
10098 {
10099 if (temp1)
10100 delete arg1;
10101 }
10102 return resultobj;
10103 fail:
10104 {
10105 if (temp1)
10106 delete arg1;
10107 }
10108 return NULL;
10109 }
10110
10111
10112 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10113 PyObject *resultobj;
10114 wxString *arg1 = 0 ;
10115 bool temp1 = false ;
10116 PyObject * obj0 = 0 ;
10117 char *kwnames[] = {
10118 (char *) "msg", NULL
10119 };
10120
10121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10122 {
10123 arg1 = wxString_in_helper(obj0);
10124 if (arg1 == NULL) SWIG_fail;
10125 temp1 = true;
10126 }
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 wxPyLogInfo((wxString const &)*arg1);
10130
10131 wxPyEndAllowThreads(__tstate);
10132 if (PyErr_Occurred()) SWIG_fail;
10133 }
10134 Py_INCREF(Py_None); resultobj = Py_None;
10135 {
10136 if (temp1)
10137 delete arg1;
10138 }
10139 return resultobj;
10140 fail:
10141 {
10142 if (temp1)
10143 delete arg1;
10144 }
10145 return NULL;
10146 }
10147
10148
10149 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10150 PyObject *resultobj;
10151 wxString *arg1 = 0 ;
10152 bool temp1 = false ;
10153 PyObject * obj0 = 0 ;
10154 char *kwnames[] = {
10155 (char *) "msg", NULL
10156 };
10157
10158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10159 {
10160 arg1 = wxString_in_helper(obj0);
10161 if (arg1 == NULL) SWIG_fail;
10162 temp1 = true;
10163 }
10164 {
10165 PyThreadState* __tstate = wxPyBeginAllowThreads();
10166 wxPyLogDebug((wxString const &)*arg1);
10167
10168 wxPyEndAllowThreads(__tstate);
10169 if (PyErr_Occurred()) SWIG_fail;
10170 }
10171 Py_INCREF(Py_None); resultobj = Py_None;
10172 {
10173 if (temp1)
10174 delete arg1;
10175 }
10176 return resultobj;
10177 fail:
10178 {
10179 if (temp1)
10180 delete arg1;
10181 }
10182 return NULL;
10183 }
10184
10185
10186 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10187 PyObject *resultobj;
10188 wxString *arg1 = 0 ;
10189 bool temp1 = false ;
10190 PyObject * obj0 = 0 ;
10191 char *kwnames[] = {
10192 (char *) "msg", NULL
10193 };
10194
10195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10196 {
10197 arg1 = wxString_in_helper(obj0);
10198 if (arg1 == NULL) SWIG_fail;
10199 temp1 = true;
10200 }
10201 {
10202 PyThreadState* __tstate = wxPyBeginAllowThreads();
10203 wxPyLogVerbose((wxString const &)*arg1);
10204
10205 wxPyEndAllowThreads(__tstate);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 Py_INCREF(Py_None); resultobj = Py_None;
10209 {
10210 if (temp1)
10211 delete arg1;
10212 }
10213 return resultobj;
10214 fail:
10215 {
10216 if (temp1)
10217 delete arg1;
10218 }
10219 return NULL;
10220 }
10221
10222
10223 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10224 PyObject *resultobj;
10225 wxString *arg1 = 0 ;
10226 bool temp1 = false ;
10227 PyObject * obj0 = 0 ;
10228 char *kwnames[] = {
10229 (char *) "msg", NULL
10230 };
10231
10232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10233 {
10234 arg1 = wxString_in_helper(obj0);
10235 if (arg1 == NULL) SWIG_fail;
10236 temp1 = true;
10237 }
10238 {
10239 PyThreadState* __tstate = wxPyBeginAllowThreads();
10240 wxPyLogStatus((wxString const &)*arg1);
10241
10242 wxPyEndAllowThreads(__tstate);
10243 if (PyErr_Occurred()) SWIG_fail;
10244 }
10245 Py_INCREF(Py_None); resultobj = Py_None;
10246 {
10247 if (temp1)
10248 delete arg1;
10249 }
10250 return resultobj;
10251 fail:
10252 {
10253 if (temp1)
10254 delete arg1;
10255 }
10256 return NULL;
10257 }
10258
10259
10260 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10261 PyObject *resultobj;
10262 wxFrame *arg1 = (wxFrame *) 0 ;
10263 wxString *arg2 = 0 ;
10264 bool temp2 = false ;
10265 PyObject * obj0 = 0 ;
10266 PyObject * obj1 = 0 ;
10267 char *kwnames[] = {
10268 (char *) "pFrame",(char *) "msg", NULL
10269 };
10270
10271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10273 if (SWIG_arg_fail(1)) SWIG_fail;
10274 {
10275 arg2 = wxString_in_helper(obj1);
10276 if (arg2 == NULL) SWIG_fail;
10277 temp2 = true;
10278 }
10279 {
10280 PyThreadState* __tstate = wxPyBeginAllowThreads();
10281 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10282
10283 wxPyEndAllowThreads(__tstate);
10284 if (PyErr_Occurred()) SWIG_fail;
10285 }
10286 Py_INCREF(Py_None); resultobj = Py_None;
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj;
10303 wxString *arg1 = 0 ;
10304 bool temp1 = false ;
10305 PyObject * obj0 = 0 ;
10306 char *kwnames[] = {
10307 (char *) "msg", NULL
10308 };
10309
10310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10311 {
10312 arg1 = wxString_in_helper(obj0);
10313 if (arg1 == NULL) SWIG_fail;
10314 temp1 = true;
10315 }
10316 {
10317 PyThreadState* __tstate = wxPyBeginAllowThreads();
10318 wxPyLogSysError((wxString const &)*arg1);
10319
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 Py_INCREF(Py_None); resultobj = Py_None;
10324 {
10325 if (temp1)
10326 delete arg1;
10327 }
10328 return resultobj;
10329 fail:
10330 {
10331 if (temp1)
10332 delete arg1;
10333 }
10334 return NULL;
10335 }
10336
10337
10338 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10339 PyObject *resultobj;
10340 unsigned long arg1 ;
10341 wxString *arg2 = 0 ;
10342 bool temp2 = false ;
10343 PyObject * obj0 = 0 ;
10344 PyObject * obj1 = 0 ;
10345 char *kwnames[] = {
10346 (char *) "level",(char *) "msg", NULL
10347 };
10348
10349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10350 {
10351 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10352 if (SWIG_arg_fail(1)) SWIG_fail;
10353 }
10354 {
10355 arg2 = wxString_in_helper(obj1);
10356 if (arg2 == NULL) SWIG_fail;
10357 temp2 = true;
10358 }
10359 {
10360 PyThreadState* __tstate = wxPyBeginAllowThreads();
10361 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10362
10363 wxPyEndAllowThreads(__tstate);
10364 if (PyErr_Occurred()) SWIG_fail;
10365 }
10366 Py_INCREF(Py_None); resultobj = Py_None;
10367 {
10368 if (temp2)
10369 delete arg2;
10370 }
10371 return resultobj;
10372 fail:
10373 {
10374 if (temp2)
10375 delete arg2;
10376 }
10377 return NULL;
10378 }
10379
10380
10381 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10382 PyObject *resultobj;
10383 unsigned long arg1 ;
10384 wxString *arg2 = 0 ;
10385 bool temp2 = false ;
10386 PyObject * obj0 = 0 ;
10387 PyObject * obj1 = 0 ;
10388
10389 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10390 {
10391 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10392 if (SWIG_arg_fail(1)) SWIG_fail;
10393 }
10394 {
10395 arg2 = wxString_in_helper(obj1);
10396 if (arg2 == NULL) SWIG_fail;
10397 temp2 = true;
10398 }
10399 {
10400 PyThreadState* __tstate = wxPyBeginAllowThreads();
10401 wxPyLogTrace(arg1,(wxString const &)*arg2);
10402
10403 wxPyEndAllowThreads(__tstate);
10404 if (PyErr_Occurred()) SWIG_fail;
10405 }
10406 Py_INCREF(Py_None); resultobj = Py_None;
10407 {
10408 if (temp2)
10409 delete arg2;
10410 }
10411 return resultobj;
10412 fail:
10413 {
10414 if (temp2)
10415 delete arg2;
10416 }
10417 return NULL;
10418 }
10419
10420
10421 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10422 PyObject *resultobj;
10423 wxString *arg1 = 0 ;
10424 wxString *arg2 = 0 ;
10425 bool temp1 = false ;
10426 bool temp2 = false ;
10427 PyObject * obj0 = 0 ;
10428 PyObject * obj1 = 0 ;
10429
10430 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10431 {
10432 arg1 = wxString_in_helper(obj0);
10433 if (arg1 == NULL) SWIG_fail;
10434 temp1 = true;
10435 }
10436 {
10437 arg2 = wxString_in_helper(obj1);
10438 if (arg2 == NULL) SWIG_fail;
10439 temp2 = true;
10440 }
10441 {
10442 PyThreadState* __tstate = wxPyBeginAllowThreads();
10443 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10444
10445 wxPyEndAllowThreads(__tstate);
10446 if (PyErr_Occurred()) SWIG_fail;
10447 }
10448 Py_INCREF(Py_None); resultobj = Py_None;
10449 {
10450 if (temp1)
10451 delete arg1;
10452 }
10453 {
10454 if (temp2)
10455 delete arg2;
10456 }
10457 return resultobj;
10458 fail:
10459 {
10460 if (temp1)
10461 delete arg1;
10462 }
10463 {
10464 if (temp2)
10465 delete arg2;
10466 }
10467 return NULL;
10468 }
10469
10470
10471 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10472 int argc;
10473 PyObject *argv[3];
10474 int ii;
10475
10476 argc = PyObject_Length(args);
10477 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10478 argv[ii] = PyTuple_GetItem(args,ii);
10479 }
10480 if (argc == 2) {
10481 int _v;
10482 {
10483 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10484 }
10485 if (_v) {
10486 {
10487 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10488 }
10489 if (_v) {
10490 return _wrap_LogTrace__SWIG_1(self,args);
10491 }
10492 }
10493 }
10494 if (argc == 2) {
10495 int _v;
10496 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10497 if (_v) {
10498 {
10499 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10500 }
10501 if (_v) {
10502 return _wrap_LogTrace__SWIG_0(self,args);
10503 }
10504 }
10505 }
10506
10507 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10508 return NULL;
10509 }
10510
10511
10512 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj;
10514 wxString *arg1 = 0 ;
10515 wxString *arg2 = 0 ;
10516 bool temp1 = false ;
10517 bool temp2 = false ;
10518 PyObject * obj0 = 0 ;
10519 PyObject * obj1 = 0 ;
10520 char *kwnames[] = {
10521 (char *) "title",(char *) "text", NULL
10522 };
10523
10524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10525 {
10526 arg1 = wxString_in_helper(obj0);
10527 if (arg1 == NULL) SWIG_fail;
10528 temp1 = true;
10529 }
10530 {
10531 arg2 = wxString_in_helper(obj1);
10532 if (arg2 == NULL) SWIG_fail;
10533 temp2 = true;
10534 }
10535 {
10536 PyThreadState* __tstate = wxPyBeginAllowThreads();
10537 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10538
10539 wxPyEndAllowThreads(__tstate);
10540 if (PyErr_Occurred()) SWIG_fail;
10541 }
10542 Py_INCREF(Py_None); resultobj = Py_None;
10543 {
10544 if (temp1)
10545 delete arg1;
10546 }
10547 {
10548 if (temp2)
10549 delete arg2;
10550 }
10551 return resultobj;
10552 fail:
10553 {
10554 if (temp1)
10555 delete arg1;
10556 }
10557 {
10558 if (temp2)
10559 delete arg2;
10560 }
10561 return NULL;
10562 }
10563
10564
10565 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10566 PyObject *resultobj;
10567 wxLogNull *result;
10568 char *kwnames[] = {
10569 NULL
10570 };
10571
10572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10573 {
10574 PyThreadState* __tstate = wxPyBeginAllowThreads();
10575 result = (wxLogNull *)new wxLogNull();
10576
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10581 return resultobj;
10582 fail:
10583 return NULL;
10584 }
10585
10586
10587 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10588 PyObject *resultobj;
10589 wxLogNull *arg1 = (wxLogNull *) 0 ;
10590 PyObject * obj0 = 0 ;
10591 char *kwnames[] = {
10592 (char *) "self", NULL
10593 };
10594
10595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10597 if (SWIG_arg_fail(1)) SWIG_fail;
10598 {
10599 PyThreadState* __tstate = wxPyBeginAllowThreads();
10600 delete arg1;
10601
10602 wxPyEndAllowThreads(__tstate);
10603 if (PyErr_Occurred()) SWIG_fail;
10604 }
10605 Py_INCREF(Py_None); resultobj = Py_None;
10606 return resultobj;
10607 fail:
10608 return NULL;
10609 }
10610
10611
10612 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10613 PyObject *obj;
10614 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10615 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10616 Py_INCREF(obj);
10617 return Py_BuildValue((char *)"");
10618 }
10619 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10620 PyObject *resultobj;
10621 wxPyLog *result;
10622 char *kwnames[] = {
10623 NULL
10624 };
10625
10626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (wxPyLog *)new wxPyLog();
10630
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10642 PyObject *resultobj;
10643 wxPyLog *arg1 = (wxPyLog *) 0 ;
10644 PyObject *arg2 = (PyObject *) 0 ;
10645 PyObject *arg3 = (PyObject *) 0 ;
10646 PyObject * obj0 = 0 ;
10647 PyObject * obj1 = 0 ;
10648 PyObject * obj2 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "self",(char *) "self",(char *) "_class", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10655 if (SWIG_arg_fail(1)) SWIG_fail;
10656 arg2 = obj1;
10657 arg3 = obj2;
10658 {
10659 PyThreadState* __tstate = wxPyBeginAllowThreads();
10660 (arg1)->_setCallbackInfo(arg2,arg3);
10661
10662 wxPyEndAllowThreads(__tstate);
10663 if (PyErr_Occurred()) SWIG_fail;
10664 }
10665 Py_INCREF(Py_None); resultobj = Py_None;
10666 return resultobj;
10667 fail:
10668 return NULL;
10669 }
10670
10671
10672 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10673 PyObject *obj;
10674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10675 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10676 Py_INCREF(obj);
10677 return Py_BuildValue((char *)"");
10678 }
10679 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10680 PyObject *resultobj;
10681 int arg1 ;
10682 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10683 int arg3 = (int) wxKILL_NOCHILDREN ;
10684 wxKillError result;
10685 PyObject * obj0 = 0 ;
10686 PyObject * obj1 = 0 ;
10687 PyObject * obj2 = 0 ;
10688 char *kwnames[] = {
10689 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10690 };
10691
10692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10693 {
10694 arg1 = (int)(SWIG_As_int(obj0));
10695 if (SWIG_arg_fail(1)) SWIG_fail;
10696 }
10697 if (obj1) {
10698 {
10699 arg2 = (wxSignal)(SWIG_As_int(obj1));
10700 if (SWIG_arg_fail(2)) SWIG_fail;
10701 }
10702 }
10703 if (obj2) {
10704 {
10705 arg3 = (int)(SWIG_As_int(obj2));
10706 if (SWIG_arg_fail(3)) SWIG_fail;
10707 }
10708 }
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10712
10713 wxPyEndAllowThreads(__tstate);
10714 if (PyErr_Occurred()) SWIG_fail;
10715 }
10716 resultobj = SWIG_From_int((result));
10717 return resultobj;
10718 fail:
10719 return NULL;
10720 }
10721
10722
10723 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10724 PyObject *resultobj;
10725 int arg1 ;
10726 bool result;
10727 PyObject * obj0 = 0 ;
10728 char *kwnames[] = {
10729 (char *) "pid", NULL
10730 };
10731
10732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10733 {
10734 arg1 = (int)(SWIG_As_int(obj0));
10735 if (SWIG_arg_fail(1)) SWIG_fail;
10736 }
10737 {
10738 PyThreadState* __tstate = wxPyBeginAllowThreads();
10739 result = (bool)wxPyProcess::Exists(arg1);
10740
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 {
10745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10746 }
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10754 PyObject *resultobj;
10755 wxString *arg1 = 0 ;
10756 int arg2 = (int) wxEXEC_ASYNC ;
10757 wxPyProcess *result;
10758 bool temp1 = false ;
10759 PyObject * obj0 = 0 ;
10760 PyObject * obj1 = 0 ;
10761 char *kwnames[] = {
10762 (char *) "cmd",(char *) "flags", NULL
10763 };
10764
10765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10766 {
10767 arg1 = wxString_in_helper(obj0);
10768 if (arg1 == NULL) SWIG_fail;
10769 temp1 = true;
10770 }
10771 if (obj1) {
10772 {
10773 arg2 = (int)(SWIG_As_int(obj1));
10774 if (SWIG_arg_fail(2)) SWIG_fail;
10775 }
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10785 {
10786 if (temp1)
10787 delete arg1;
10788 }
10789 return resultobj;
10790 fail:
10791 {
10792 if (temp1)
10793 delete arg1;
10794 }
10795 return NULL;
10796 }
10797
10798
10799 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10800 PyObject *resultobj;
10801 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10802 int arg2 = (int) -1 ;
10803 wxPyProcess *result;
10804 PyObject * obj0 = 0 ;
10805 PyObject * obj1 = 0 ;
10806 char *kwnames[] = {
10807 (char *) "parent",(char *) "id", NULL
10808 };
10809
10810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10811 if (obj0) {
10812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10813 if (SWIG_arg_fail(1)) SWIG_fail;
10814 }
10815 if (obj1) {
10816 {
10817 arg2 = (int)(SWIG_As_int(obj1));
10818 if (SWIG_arg_fail(2)) SWIG_fail;
10819 }
10820 }
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10824
10825 wxPyEndAllowThreads(__tstate);
10826 if (PyErr_Occurred()) SWIG_fail;
10827 }
10828 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10829 return resultobj;
10830 fail:
10831 return NULL;
10832 }
10833
10834
10835 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10836 PyObject *resultobj;
10837 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10838 PyObject *arg2 = (PyObject *) 0 ;
10839 PyObject *arg3 = (PyObject *) 0 ;
10840 PyObject * obj0 = 0 ;
10841 PyObject * obj1 = 0 ;
10842 PyObject * obj2 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self",(char *) "self",(char *) "_class", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 arg2 = obj1;
10851 arg3 = obj2;
10852 {
10853 PyThreadState* __tstate = wxPyBeginAllowThreads();
10854 (arg1)->_setCallbackInfo(arg2,arg3);
10855
10856 wxPyEndAllowThreads(__tstate);
10857 if (PyErr_Occurred()) SWIG_fail;
10858 }
10859 Py_INCREF(Py_None); resultobj = Py_None;
10860 return resultobj;
10861 fail:
10862 return NULL;
10863 }
10864
10865
10866 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10867 PyObject *resultobj;
10868 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10869 int arg2 ;
10870 int arg3 ;
10871 PyObject * obj0 = 0 ;
10872 PyObject * obj1 = 0 ;
10873 PyObject * obj2 = 0 ;
10874 char *kwnames[] = {
10875 (char *) "self",(char *) "pid",(char *) "status", NULL
10876 };
10877
10878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10880 if (SWIG_arg_fail(1)) SWIG_fail;
10881 {
10882 arg2 = (int)(SWIG_As_int(obj1));
10883 if (SWIG_arg_fail(2)) SWIG_fail;
10884 }
10885 {
10886 arg3 = (int)(SWIG_As_int(obj2));
10887 if (SWIG_arg_fail(3)) SWIG_fail;
10888 }
10889 {
10890 PyThreadState* __tstate = wxPyBeginAllowThreads();
10891 (arg1)->base_OnTerminate(arg2,arg3);
10892
10893 wxPyEndAllowThreads(__tstate);
10894 if (PyErr_Occurred()) SWIG_fail;
10895 }
10896 Py_INCREF(Py_None); resultobj = Py_None;
10897 return resultobj;
10898 fail:
10899 return NULL;
10900 }
10901
10902
10903 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10904 PyObject *resultobj;
10905 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10906 PyObject * obj0 = 0 ;
10907 char *kwnames[] = {
10908 (char *) "self", NULL
10909 };
10910
10911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10913 if (SWIG_arg_fail(1)) SWIG_fail;
10914 {
10915 PyThreadState* __tstate = wxPyBeginAllowThreads();
10916 (arg1)->Redirect();
10917
10918 wxPyEndAllowThreads(__tstate);
10919 if (PyErr_Occurred()) SWIG_fail;
10920 }
10921 Py_INCREF(Py_None); resultobj = Py_None;
10922 return resultobj;
10923 fail:
10924 return NULL;
10925 }
10926
10927
10928 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10929 PyObject *resultobj;
10930 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10931 bool result;
10932 PyObject * obj0 = 0 ;
10933 char *kwnames[] = {
10934 (char *) "self", NULL
10935 };
10936
10937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10939 if (SWIG_arg_fail(1)) SWIG_fail;
10940 {
10941 PyThreadState* __tstate = wxPyBeginAllowThreads();
10942 result = (bool)(arg1)->IsRedirected();
10943
10944 wxPyEndAllowThreads(__tstate);
10945 if (PyErr_Occurred()) SWIG_fail;
10946 }
10947 {
10948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10949 }
10950 return resultobj;
10951 fail:
10952 return NULL;
10953 }
10954
10955
10956 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10957 PyObject *resultobj;
10958 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10959 PyObject * obj0 = 0 ;
10960 char *kwnames[] = {
10961 (char *) "self", NULL
10962 };
10963
10964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10966 if (SWIG_arg_fail(1)) SWIG_fail;
10967 {
10968 PyThreadState* __tstate = wxPyBeginAllowThreads();
10969 (arg1)->Detach();
10970
10971 wxPyEndAllowThreads(__tstate);
10972 if (PyErr_Occurred()) SWIG_fail;
10973 }
10974 Py_INCREF(Py_None); resultobj = Py_None;
10975 return resultobj;
10976 fail:
10977 return NULL;
10978 }
10979
10980
10981 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj;
10983 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10984 wxInputStream *result;
10985 PyObject * obj0 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 PyThreadState* __tstate = wxPyBeginAllowThreads();
10995 result = (wxInputStream *)(arg1)->GetInputStream();
10996
10997 wxPyEndAllowThreads(__tstate);
10998 if (PyErr_Occurred()) SWIG_fail;
10999 }
11000 {
11001 wxPyInputStream * _ptr = NULL;
11002
11003 if (result) {
11004 _ptr = new wxPyInputStream(result);
11005 }
11006 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11017 wxInputStream *result;
11018 PyObject * obj0 = 0 ;
11019 char *kwnames[] = {
11020 (char *) "self", NULL
11021 };
11022
11023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11025 if (SWIG_arg_fail(1)) SWIG_fail;
11026 {
11027 PyThreadState* __tstate = wxPyBeginAllowThreads();
11028 result = (wxInputStream *)(arg1)->GetErrorStream();
11029
11030 wxPyEndAllowThreads(__tstate);
11031 if (PyErr_Occurred()) SWIG_fail;
11032 }
11033 {
11034 wxPyInputStream * _ptr = NULL;
11035
11036 if (result) {
11037 _ptr = new wxPyInputStream(result);
11038 }
11039 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11040 }
11041 return resultobj;
11042 fail:
11043 return NULL;
11044 }
11045
11046
11047 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11048 PyObject *resultobj;
11049 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11050 wxOutputStream *result;
11051 PyObject * obj0 = 0 ;
11052 char *kwnames[] = {
11053 (char *) "self", NULL
11054 };
11055
11056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11058 if (SWIG_arg_fail(1)) SWIG_fail;
11059 {
11060 PyThreadState* __tstate = wxPyBeginAllowThreads();
11061 result = (wxOutputStream *)(arg1)->GetOutputStream();
11062
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11074 PyObject *resultobj;
11075 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11076 PyObject * obj0 = 0 ;
11077 char *kwnames[] = {
11078 (char *) "self", NULL
11079 };
11080
11081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11083 if (SWIG_arg_fail(1)) SWIG_fail;
11084 {
11085 PyThreadState* __tstate = wxPyBeginAllowThreads();
11086 (arg1)->CloseOutput();
11087
11088 wxPyEndAllowThreads(__tstate);
11089 if (PyErr_Occurred()) SWIG_fail;
11090 }
11091 Py_INCREF(Py_None); resultobj = Py_None;
11092 return resultobj;
11093 fail:
11094 return NULL;
11095 }
11096
11097
11098 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11099 PyObject *resultobj;
11100 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11101 bool result;
11102 PyObject * obj0 = 0 ;
11103 char *kwnames[] = {
11104 (char *) "self", NULL
11105 };
11106
11107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11109 if (SWIG_arg_fail(1)) SWIG_fail;
11110 {
11111 PyThreadState* __tstate = wxPyBeginAllowThreads();
11112 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11113
11114 wxPyEndAllowThreads(__tstate);
11115 if (PyErr_Occurred()) SWIG_fail;
11116 }
11117 {
11118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11119 }
11120 return resultobj;
11121 fail:
11122 return NULL;
11123 }
11124
11125
11126 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj;
11128 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11129 bool result;
11130 PyObject * obj0 = 0 ;
11131 char *kwnames[] = {
11132 (char *) "self", NULL
11133 };
11134
11135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11137 if (SWIG_arg_fail(1)) SWIG_fail;
11138 {
11139 PyThreadState* __tstate = wxPyBeginAllowThreads();
11140 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11141
11142 wxPyEndAllowThreads(__tstate);
11143 if (PyErr_Occurred()) SWIG_fail;
11144 }
11145 {
11146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11147 }
11148 return resultobj;
11149 fail:
11150 return NULL;
11151 }
11152
11153
11154 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11155 PyObject *resultobj;
11156 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11157 bool result;
11158 PyObject * obj0 = 0 ;
11159 char *kwnames[] = {
11160 (char *) "self", NULL
11161 };
11162
11163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11165 if (SWIG_arg_fail(1)) SWIG_fail;
11166 {
11167 PyThreadState* __tstate = wxPyBeginAllowThreads();
11168 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11169
11170 wxPyEndAllowThreads(__tstate);
11171 if (PyErr_Occurred()) SWIG_fail;
11172 }
11173 {
11174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11175 }
11176 return resultobj;
11177 fail:
11178 return NULL;
11179 }
11180
11181
11182 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11183 PyObject *obj;
11184 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11185 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11186 Py_INCREF(obj);
11187 return Py_BuildValue((char *)"");
11188 }
11189 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11190 PyObject *resultobj;
11191 int arg1 = (int) 0 ;
11192 int arg2 = (int) 0 ;
11193 int arg3 = (int) 0 ;
11194 wxProcessEvent *result;
11195 PyObject * obj0 = 0 ;
11196 PyObject * obj1 = 0 ;
11197 PyObject * obj2 = 0 ;
11198 char *kwnames[] = {
11199 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11200 };
11201
11202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11203 if (obj0) {
11204 {
11205 arg1 = (int)(SWIG_As_int(obj0));
11206 if (SWIG_arg_fail(1)) SWIG_fail;
11207 }
11208 }
11209 if (obj1) {
11210 {
11211 arg2 = (int)(SWIG_As_int(obj1));
11212 if (SWIG_arg_fail(2)) SWIG_fail;
11213 }
11214 }
11215 if (obj2) {
11216 {
11217 arg3 = (int)(SWIG_As_int(obj2));
11218 if (SWIG_arg_fail(3)) SWIG_fail;
11219 }
11220 }
11221 {
11222 PyThreadState* __tstate = wxPyBeginAllowThreads();
11223 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11224
11225 wxPyEndAllowThreads(__tstate);
11226 if (PyErr_Occurred()) SWIG_fail;
11227 }
11228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11229 return resultobj;
11230 fail:
11231 return NULL;
11232 }
11233
11234
11235 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11236 PyObject *resultobj;
11237 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11238 int result;
11239 PyObject * obj0 = 0 ;
11240 char *kwnames[] = {
11241 (char *) "self", NULL
11242 };
11243
11244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11246 if (SWIG_arg_fail(1)) SWIG_fail;
11247 {
11248 PyThreadState* __tstate = wxPyBeginAllowThreads();
11249 result = (int)(arg1)->GetPid();
11250
11251 wxPyEndAllowThreads(__tstate);
11252 if (PyErr_Occurred()) SWIG_fail;
11253 }
11254 {
11255 resultobj = SWIG_From_int((int)(result));
11256 }
11257 return resultobj;
11258 fail:
11259 return NULL;
11260 }
11261
11262
11263 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj;
11265 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11266 int result;
11267 PyObject * obj0 = 0 ;
11268 char *kwnames[] = {
11269 (char *) "self", NULL
11270 };
11271
11272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11274 if (SWIG_arg_fail(1)) SWIG_fail;
11275 {
11276 PyThreadState* __tstate = wxPyBeginAllowThreads();
11277 result = (int)(arg1)->GetExitCode();
11278
11279 wxPyEndAllowThreads(__tstate);
11280 if (PyErr_Occurred()) SWIG_fail;
11281 }
11282 {
11283 resultobj = SWIG_From_int((int)(result));
11284 }
11285 return resultobj;
11286 fail:
11287 return NULL;
11288 }
11289
11290
11291 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11292 PyObject *resultobj;
11293 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11294 int arg2 ;
11295 PyObject * obj0 = 0 ;
11296 PyObject * obj1 = 0 ;
11297 char *kwnames[] = {
11298 (char *) "self",(char *) "m_pid", NULL
11299 };
11300
11301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11303 if (SWIG_arg_fail(1)) SWIG_fail;
11304 {
11305 arg2 = (int)(SWIG_As_int(obj1));
11306 if (SWIG_arg_fail(2)) SWIG_fail;
11307 }
11308 if (arg1) (arg1)->m_pid = arg2;
11309
11310 Py_INCREF(Py_None); resultobj = Py_None;
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj;
11319 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11320 int result;
11321 PyObject * obj0 = 0 ;
11322 char *kwnames[] = {
11323 (char *) "self", NULL
11324 };
11325
11326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11328 if (SWIG_arg_fail(1)) SWIG_fail;
11329 result = (int) ((arg1)->m_pid);
11330
11331 {
11332 resultobj = SWIG_From_int((int)(result));
11333 }
11334 return resultobj;
11335 fail:
11336 return NULL;
11337 }
11338
11339
11340 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11341 PyObject *resultobj;
11342 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11343 int arg2 ;
11344 PyObject * obj0 = 0 ;
11345 PyObject * obj1 = 0 ;
11346 char *kwnames[] = {
11347 (char *) "self",(char *) "m_exitcode", NULL
11348 };
11349
11350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11352 if (SWIG_arg_fail(1)) SWIG_fail;
11353 {
11354 arg2 = (int)(SWIG_As_int(obj1));
11355 if (SWIG_arg_fail(2)) SWIG_fail;
11356 }
11357 if (arg1) (arg1)->m_exitcode = arg2;
11358
11359 Py_INCREF(Py_None); resultobj = Py_None;
11360 return resultobj;
11361 fail:
11362 return NULL;
11363 }
11364
11365
11366 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11367 PyObject *resultobj;
11368 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11369 int result;
11370 PyObject * obj0 = 0 ;
11371 char *kwnames[] = {
11372 (char *) "self", NULL
11373 };
11374
11375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11377 if (SWIG_arg_fail(1)) SWIG_fail;
11378 result = (int) ((arg1)->m_exitcode);
11379
11380 {
11381 resultobj = SWIG_From_int((int)(result));
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11390 PyObject *obj;
11391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11392 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11393 Py_INCREF(obj);
11394 return Py_BuildValue((char *)"");
11395 }
11396 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11397 PyObject *resultobj;
11398 wxString *arg1 = 0 ;
11399 int arg2 = (int) wxEXEC_ASYNC ;
11400 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11401 long result;
11402 bool temp1 = false ;
11403 PyObject * obj0 = 0 ;
11404 PyObject * obj1 = 0 ;
11405 PyObject * obj2 = 0 ;
11406 char *kwnames[] = {
11407 (char *) "command",(char *) "flags",(char *) "process", NULL
11408 };
11409
11410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11411 {
11412 arg1 = wxString_in_helper(obj0);
11413 if (arg1 == NULL) SWIG_fail;
11414 temp1 = true;
11415 }
11416 if (obj1) {
11417 {
11418 arg2 = (int)(SWIG_As_int(obj1));
11419 if (SWIG_arg_fail(2)) SWIG_fail;
11420 }
11421 }
11422 if (obj2) {
11423 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11424 if (SWIG_arg_fail(3)) SWIG_fail;
11425 }
11426 {
11427 if (!wxPyCheckForApp()) SWIG_fail;
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11430
11431 wxPyEndAllowThreads(__tstate);
11432 if (PyErr_Occurred()) SWIG_fail;
11433 }
11434 {
11435 resultobj = SWIG_From_long((long)(result));
11436 }
11437 {
11438 if (temp1)
11439 delete arg1;
11440 }
11441 return resultobj;
11442 fail:
11443 {
11444 if (temp1)
11445 delete arg1;
11446 }
11447 return NULL;
11448 }
11449
11450
11451 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11452 PyObject *resultobj;
11453 long arg1 ;
11454 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11455 wxKillError *arg3 = (wxKillError *) 0 ;
11456 int arg4 = (int) wxKILL_NOCHILDREN ;
11457 int result;
11458 wxKillError temp3 ;
11459 PyObject * obj0 = 0 ;
11460 PyObject * obj1 = 0 ;
11461 PyObject * obj2 = 0 ;
11462 char *kwnames[] = {
11463 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11464 };
11465
11466 {
11467 arg3 = &temp3;
11468 }
11469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11470 {
11471 arg1 = (long)(SWIG_As_long(obj0));
11472 if (SWIG_arg_fail(1)) SWIG_fail;
11473 }
11474 if (obj1) {
11475 {
11476 arg2 = (wxSignal)(SWIG_As_int(obj1));
11477 if (SWIG_arg_fail(2)) SWIG_fail;
11478 }
11479 }
11480 if (obj2) {
11481 {
11482 arg4 = (int)(SWIG_As_int(obj2));
11483 if (SWIG_arg_fail(4)) SWIG_fail;
11484 }
11485 }
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11489
11490 wxPyEndAllowThreads(__tstate);
11491 if (PyErr_Occurred()) SWIG_fail;
11492 }
11493 {
11494 resultobj = SWIG_From_int((int)(result));
11495 }
11496 {
11497 PyObject* o;
11498 o = PyInt_FromLong((long) (*arg3));
11499 resultobj = t_output_helper(resultobj, o);
11500 }
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj;
11509 int arg1 = (int) wxJOYSTICK1 ;
11510 wxJoystick *result;
11511 PyObject * obj0 = 0 ;
11512 char *kwnames[] = {
11513 (char *) "joystick", NULL
11514 };
11515
11516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11517 if (obj0) {
11518 {
11519 arg1 = (int)(SWIG_As_int(obj0));
11520 if (SWIG_arg_fail(1)) SWIG_fail;
11521 }
11522 }
11523 {
11524 if (!wxPyCheckForApp()) SWIG_fail;
11525 PyThreadState* __tstate = wxPyBeginAllowThreads();
11526 result = (wxJoystick *)new wxJoystick(arg1);
11527
11528 wxPyEndAllowThreads(__tstate);
11529 if (PyErr_Occurred()) SWIG_fail;
11530 }
11531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11532 return resultobj;
11533 fail:
11534 return NULL;
11535 }
11536
11537
11538 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11539 PyObject *resultobj;
11540 wxJoystick *arg1 = (wxJoystick *) 0 ;
11541 PyObject * obj0 = 0 ;
11542 char *kwnames[] = {
11543 (char *) "self", NULL
11544 };
11545
11546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11548 if (SWIG_arg_fail(1)) SWIG_fail;
11549 {
11550 PyThreadState* __tstate = wxPyBeginAllowThreads();
11551 delete arg1;
11552
11553 wxPyEndAllowThreads(__tstate);
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 Py_INCREF(Py_None); resultobj = Py_None;
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj;
11565 wxJoystick *arg1 = (wxJoystick *) 0 ;
11566 wxPoint result;
11567 PyObject * obj0 = 0 ;
11568 char *kwnames[] = {
11569 (char *) "self", NULL
11570 };
11571
11572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11574 if (SWIG_arg_fail(1)) SWIG_fail;
11575 {
11576 PyThreadState* __tstate = wxPyBeginAllowThreads();
11577 result = (arg1)->GetPosition();
11578
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 {
11583 wxPoint * resultptr;
11584 resultptr = new wxPoint((wxPoint &)(result));
11585 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11586 }
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj;
11595 wxJoystick *arg1 = (wxJoystick *) 0 ;
11596 int result;
11597 PyObject * obj0 = 0 ;
11598 char *kwnames[] = {
11599 (char *) "self", NULL
11600 };
11601
11602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11604 if (SWIG_arg_fail(1)) SWIG_fail;
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 result = (int)(arg1)->GetZPosition();
11608
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = SWIG_From_int((int)(result));
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj;
11623 wxJoystick *arg1 = (wxJoystick *) 0 ;
11624 int result;
11625 PyObject * obj0 = 0 ;
11626 char *kwnames[] = {
11627 (char *) "self", NULL
11628 };
11629
11630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11632 if (SWIG_arg_fail(1)) SWIG_fail;
11633 {
11634 PyThreadState* __tstate = wxPyBeginAllowThreads();
11635 result = (int)(arg1)->GetButtonState();
11636
11637 wxPyEndAllowThreads(__tstate);
11638 if (PyErr_Occurred()) SWIG_fail;
11639 }
11640 {
11641 resultobj = SWIG_From_int((int)(result));
11642 }
11643 return resultobj;
11644 fail:
11645 return NULL;
11646 }
11647
11648
11649 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11650 PyObject *resultobj;
11651 wxJoystick *arg1 = (wxJoystick *) 0 ;
11652 int result;
11653 PyObject * obj0 = 0 ;
11654 char *kwnames[] = {
11655 (char *) "self", NULL
11656 };
11657
11658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11660 if (SWIG_arg_fail(1)) SWIG_fail;
11661 {
11662 PyThreadState* __tstate = wxPyBeginAllowThreads();
11663 result = (int)(arg1)->GetPOVPosition();
11664
11665 wxPyEndAllowThreads(__tstate);
11666 if (PyErr_Occurred()) SWIG_fail;
11667 }
11668 {
11669 resultobj = SWIG_From_int((int)(result));
11670 }
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj;
11679 wxJoystick *arg1 = (wxJoystick *) 0 ;
11680 int result;
11681 PyObject * obj0 = 0 ;
11682 char *kwnames[] = {
11683 (char *) "self", NULL
11684 };
11685
11686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11688 if (SWIG_arg_fail(1)) SWIG_fail;
11689 {
11690 PyThreadState* __tstate = wxPyBeginAllowThreads();
11691 result = (int)(arg1)->GetPOVCTSPosition();
11692
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 {
11697 resultobj = SWIG_From_int((int)(result));
11698 }
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11706 PyObject *resultobj;
11707 wxJoystick *arg1 = (wxJoystick *) 0 ;
11708 int result;
11709 PyObject * obj0 = 0 ;
11710 char *kwnames[] = {
11711 (char *) "self", NULL
11712 };
11713
11714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11716 if (SWIG_arg_fail(1)) SWIG_fail;
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (int)(arg1)->GetRudderPosition();
11720
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = SWIG_From_int((int)(result));
11726 }
11727 return resultobj;
11728 fail:
11729 return NULL;
11730 }
11731
11732
11733 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11734 PyObject *resultobj;
11735 wxJoystick *arg1 = (wxJoystick *) 0 ;
11736 int result;
11737 PyObject * obj0 = 0 ;
11738 char *kwnames[] = {
11739 (char *) "self", NULL
11740 };
11741
11742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11744 if (SWIG_arg_fail(1)) SWIG_fail;
11745 {
11746 PyThreadState* __tstate = wxPyBeginAllowThreads();
11747 result = (int)(arg1)->GetUPosition();
11748
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 {
11753 resultobj = SWIG_From_int((int)(result));
11754 }
11755 return resultobj;
11756 fail:
11757 return NULL;
11758 }
11759
11760
11761 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11762 PyObject *resultobj;
11763 wxJoystick *arg1 = (wxJoystick *) 0 ;
11764 int result;
11765 PyObject * obj0 = 0 ;
11766 char *kwnames[] = {
11767 (char *) "self", NULL
11768 };
11769
11770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11772 if (SWIG_arg_fail(1)) SWIG_fail;
11773 {
11774 PyThreadState* __tstate = wxPyBeginAllowThreads();
11775 result = (int)(arg1)->GetVPosition();
11776
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 {
11781 resultobj = SWIG_From_int((int)(result));
11782 }
11783 return resultobj;
11784 fail:
11785 return NULL;
11786 }
11787
11788
11789 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11790 PyObject *resultobj;
11791 wxJoystick *arg1 = (wxJoystick *) 0 ;
11792 int result;
11793 PyObject * obj0 = 0 ;
11794 char *kwnames[] = {
11795 (char *) "self", NULL
11796 };
11797
11798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11800 if (SWIG_arg_fail(1)) SWIG_fail;
11801 {
11802 PyThreadState* __tstate = wxPyBeginAllowThreads();
11803 result = (int)(arg1)->GetMovementThreshold();
11804
11805 wxPyEndAllowThreads(__tstate);
11806 if (PyErr_Occurred()) SWIG_fail;
11807 }
11808 {
11809 resultobj = SWIG_From_int((int)(result));
11810 }
11811 return resultobj;
11812 fail:
11813 return NULL;
11814 }
11815
11816
11817 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11818 PyObject *resultobj;
11819 wxJoystick *arg1 = (wxJoystick *) 0 ;
11820 int arg2 ;
11821 PyObject * obj0 = 0 ;
11822 PyObject * obj1 = 0 ;
11823 char *kwnames[] = {
11824 (char *) "self",(char *) "threshold", NULL
11825 };
11826
11827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11829 if (SWIG_arg_fail(1)) SWIG_fail;
11830 {
11831 arg2 = (int)(SWIG_As_int(obj1));
11832 if (SWIG_arg_fail(2)) SWIG_fail;
11833 }
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 (arg1)->SetMovementThreshold(arg2);
11837
11838 wxPyEndAllowThreads(__tstate);
11839 if (PyErr_Occurred()) SWIG_fail;
11840 }
11841 Py_INCREF(Py_None); resultobj = Py_None;
11842 return resultobj;
11843 fail:
11844 return NULL;
11845 }
11846
11847
11848 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11849 PyObject *resultobj;
11850 wxJoystick *arg1 = (wxJoystick *) 0 ;
11851 bool result;
11852 PyObject * obj0 = 0 ;
11853 char *kwnames[] = {
11854 (char *) "self", NULL
11855 };
11856
11857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11859 if (SWIG_arg_fail(1)) SWIG_fail;
11860 {
11861 PyThreadState* __tstate = wxPyBeginAllowThreads();
11862 result = (bool)(arg1)->IsOk();
11863
11864 wxPyEndAllowThreads(__tstate);
11865 if (PyErr_Occurred()) SWIG_fail;
11866 }
11867 {
11868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11869 }
11870 return resultobj;
11871 fail:
11872 return NULL;
11873 }
11874
11875
11876 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11877 PyObject *resultobj;
11878 wxJoystick *arg1 = (wxJoystick *) 0 ;
11879 int result;
11880 PyObject * obj0 = 0 ;
11881 char *kwnames[] = {
11882 (char *) "self", NULL
11883 };
11884
11885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11887 if (SWIG_arg_fail(1)) SWIG_fail;
11888 {
11889 PyThreadState* __tstate = wxPyBeginAllowThreads();
11890 result = (int)(arg1)->GetNumberJoysticks();
11891
11892 wxPyEndAllowThreads(__tstate);
11893 if (PyErr_Occurred()) SWIG_fail;
11894 }
11895 {
11896 resultobj = SWIG_From_int((int)(result));
11897 }
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj;
11906 wxJoystick *arg1 = (wxJoystick *) 0 ;
11907 int result;
11908 PyObject * obj0 = 0 ;
11909 char *kwnames[] = {
11910 (char *) "self", NULL
11911 };
11912
11913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11915 if (SWIG_arg_fail(1)) SWIG_fail;
11916 {
11917 PyThreadState* __tstate = wxPyBeginAllowThreads();
11918 result = (int)(arg1)->GetManufacturerId();
11919
11920 wxPyEndAllowThreads(__tstate);
11921 if (PyErr_Occurred()) SWIG_fail;
11922 }
11923 {
11924 resultobj = SWIG_From_int((int)(result));
11925 }
11926 return resultobj;
11927 fail:
11928 return NULL;
11929 }
11930
11931
11932 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11933 PyObject *resultobj;
11934 wxJoystick *arg1 = (wxJoystick *) 0 ;
11935 int result;
11936 PyObject * obj0 = 0 ;
11937 char *kwnames[] = {
11938 (char *) "self", NULL
11939 };
11940
11941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11943 if (SWIG_arg_fail(1)) SWIG_fail;
11944 {
11945 PyThreadState* __tstate = wxPyBeginAllowThreads();
11946 result = (int)(arg1)->GetProductId();
11947
11948 wxPyEndAllowThreads(__tstate);
11949 if (PyErr_Occurred()) SWIG_fail;
11950 }
11951 {
11952 resultobj = SWIG_From_int((int)(result));
11953 }
11954 return resultobj;
11955 fail:
11956 return NULL;
11957 }
11958
11959
11960 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11961 PyObject *resultobj;
11962 wxJoystick *arg1 = (wxJoystick *) 0 ;
11963 wxString result;
11964 PyObject * obj0 = 0 ;
11965 char *kwnames[] = {
11966 (char *) "self", NULL
11967 };
11968
11969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11971 if (SWIG_arg_fail(1)) SWIG_fail;
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (arg1)->GetProductName();
11975
11976 wxPyEndAllowThreads(__tstate);
11977 if (PyErr_Occurred()) SWIG_fail;
11978 }
11979 {
11980 #if wxUSE_UNICODE
11981 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11982 #else
11983 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11984 #endif
11985 }
11986 return resultobj;
11987 fail:
11988 return NULL;
11989 }
11990
11991
11992 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11993 PyObject *resultobj;
11994 wxJoystick *arg1 = (wxJoystick *) 0 ;
11995 int result;
11996 PyObject * obj0 = 0 ;
11997 char *kwnames[] = {
11998 (char *) "self", NULL
11999 };
12000
12001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12003 if (SWIG_arg_fail(1)) SWIG_fail;
12004 {
12005 PyThreadState* __tstate = wxPyBeginAllowThreads();
12006 result = (int)(arg1)->GetXMin();
12007
12008 wxPyEndAllowThreads(__tstate);
12009 if (PyErr_Occurred()) SWIG_fail;
12010 }
12011 {
12012 resultobj = SWIG_From_int((int)(result));
12013 }
12014 return resultobj;
12015 fail:
12016 return NULL;
12017 }
12018
12019
12020 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12021 PyObject *resultobj;
12022 wxJoystick *arg1 = (wxJoystick *) 0 ;
12023 int result;
12024 PyObject * obj0 = 0 ;
12025 char *kwnames[] = {
12026 (char *) "self", NULL
12027 };
12028
12029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12031 if (SWIG_arg_fail(1)) SWIG_fail;
12032 {
12033 PyThreadState* __tstate = wxPyBeginAllowThreads();
12034 result = (int)(arg1)->GetYMin();
12035
12036 wxPyEndAllowThreads(__tstate);
12037 if (PyErr_Occurred()) SWIG_fail;
12038 }
12039 {
12040 resultobj = SWIG_From_int((int)(result));
12041 }
12042 return resultobj;
12043 fail:
12044 return NULL;
12045 }
12046
12047
12048 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12049 PyObject *resultobj;
12050 wxJoystick *arg1 = (wxJoystick *) 0 ;
12051 int result;
12052 PyObject * obj0 = 0 ;
12053 char *kwnames[] = {
12054 (char *) "self", NULL
12055 };
12056
12057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12059 if (SWIG_arg_fail(1)) SWIG_fail;
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (int)(arg1)->GetZMin();
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 {
12068 resultobj = SWIG_From_int((int)(result));
12069 }
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj;
12078 wxJoystick *arg1 = (wxJoystick *) 0 ;
12079 int result;
12080 PyObject * obj0 = 0 ;
12081 char *kwnames[] = {
12082 (char *) "self", NULL
12083 };
12084
12085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12087 if (SWIG_arg_fail(1)) SWIG_fail;
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 result = (int)(arg1)->GetXMax();
12091
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 {
12096 resultobj = SWIG_From_int((int)(result));
12097 }
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj;
12106 wxJoystick *arg1 = (wxJoystick *) 0 ;
12107 int result;
12108 PyObject * obj0 = 0 ;
12109 char *kwnames[] = {
12110 (char *) "self", NULL
12111 };
12112
12113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12115 if (SWIG_arg_fail(1)) SWIG_fail;
12116 {
12117 PyThreadState* __tstate = wxPyBeginAllowThreads();
12118 result = (int)(arg1)->GetYMax();
12119
12120 wxPyEndAllowThreads(__tstate);
12121 if (PyErr_Occurred()) SWIG_fail;
12122 }
12123 {
12124 resultobj = SWIG_From_int((int)(result));
12125 }
12126 return resultobj;
12127 fail:
12128 return NULL;
12129 }
12130
12131
12132 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12133 PyObject *resultobj;
12134 wxJoystick *arg1 = (wxJoystick *) 0 ;
12135 int result;
12136 PyObject * obj0 = 0 ;
12137 char *kwnames[] = {
12138 (char *) "self", NULL
12139 };
12140
12141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12143 if (SWIG_arg_fail(1)) SWIG_fail;
12144 {
12145 PyThreadState* __tstate = wxPyBeginAllowThreads();
12146 result = (int)(arg1)->GetZMax();
12147
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 resultobj = SWIG_From_int((int)(result));
12153 }
12154 return resultobj;
12155 fail:
12156 return NULL;
12157 }
12158
12159
12160 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12161 PyObject *resultobj;
12162 wxJoystick *arg1 = (wxJoystick *) 0 ;
12163 int result;
12164 PyObject * obj0 = 0 ;
12165 char *kwnames[] = {
12166 (char *) "self", NULL
12167 };
12168
12169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12171 if (SWIG_arg_fail(1)) SWIG_fail;
12172 {
12173 PyThreadState* __tstate = wxPyBeginAllowThreads();
12174 result = (int)(arg1)->GetNumberButtons();
12175
12176 wxPyEndAllowThreads(__tstate);
12177 if (PyErr_Occurred()) SWIG_fail;
12178 }
12179 {
12180 resultobj = SWIG_From_int((int)(result));
12181 }
12182 return resultobj;
12183 fail:
12184 return NULL;
12185 }
12186
12187
12188 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12189 PyObject *resultobj;
12190 wxJoystick *arg1 = (wxJoystick *) 0 ;
12191 int result;
12192 PyObject * obj0 = 0 ;
12193 char *kwnames[] = {
12194 (char *) "self", NULL
12195 };
12196
12197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12199 if (SWIG_arg_fail(1)) SWIG_fail;
12200 {
12201 PyThreadState* __tstate = wxPyBeginAllowThreads();
12202 result = (int)(arg1)->GetNumberAxes();
12203
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 {
12208 resultobj = SWIG_From_int((int)(result));
12209 }
12210 return resultobj;
12211 fail:
12212 return NULL;
12213 }
12214
12215
12216 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12217 PyObject *resultobj;
12218 wxJoystick *arg1 = (wxJoystick *) 0 ;
12219 int result;
12220 PyObject * obj0 = 0 ;
12221 char *kwnames[] = {
12222 (char *) "self", NULL
12223 };
12224
12225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12227 if (SWIG_arg_fail(1)) SWIG_fail;
12228 {
12229 PyThreadState* __tstate = wxPyBeginAllowThreads();
12230 result = (int)(arg1)->GetMaxButtons();
12231
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 {
12236 resultobj = SWIG_From_int((int)(result));
12237 }
12238 return resultobj;
12239 fail:
12240 return NULL;
12241 }
12242
12243
12244 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12245 PyObject *resultobj;
12246 wxJoystick *arg1 = (wxJoystick *) 0 ;
12247 int result;
12248 PyObject * obj0 = 0 ;
12249 char *kwnames[] = {
12250 (char *) "self", NULL
12251 };
12252
12253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12255 if (SWIG_arg_fail(1)) SWIG_fail;
12256 {
12257 PyThreadState* __tstate = wxPyBeginAllowThreads();
12258 result = (int)(arg1)->GetMaxAxes();
12259
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 {
12264 resultobj = SWIG_From_int((int)(result));
12265 }
12266 return resultobj;
12267 fail:
12268 return NULL;
12269 }
12270
12271
12272 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12273 PyObject *resultobj;
12274 wxJoystick *arg1 = (wxJoystick *) 0 ;
12275 int result;
12276 PyObject * obj0 = 0 ;
12277 char *kwnames[] = {
12278 (char *) "self", NULL
12279 };
12280
12281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12283 if (SWIG_arg_fail(1)) SWIG_fail;
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (int)(arg1)->GetPollingMin();
12287
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 {
12292 resultobj = SWIG_From_int((int)(result));
12293 }
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj;
12302 wxJoystick *arg1 = (wxJoystick *) 0 ;
12303 int result;
12304 PyObject * obj0 = 0 ;
12305 char *kwnames[] = {
12306 (char *) "self", NULL
12307 };
12308
12309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12311 if (SWIG_arg_fail(1)) SWIG_fail;
12312 {
12313 PyThreadState* __tstate = wxPyBeginAllowThreads();
12314 result = (int)(arg1)->GetPollingMax();
12315
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 resultobj = SWIG_From_int((int)(result));
12321 }
12322 return resultobj;
12323 fail:
12324 return NULL;
12325 }
12326
12327
12328 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12329 PyObject *resultobj;
12330 wxJoystick *arg1 = (wxJoystick *) 0 ;
12331 int result;
12332 PyObject * obj0 = 0 ;
12333 char *kwnames[] = {
12334 (char *) "self", NULL
12335 };
12336
12337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12339 if (SWIG_arg_fail(1)) SWIG_fail;
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 result = (int)(arg1)->GetRudderMin();
12343
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = SWIG_From_int((int)(result));
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12357 PyObject *resultobj;
12358 wxJoystick *arg1 = (wxJoystick *) 0 ;
12359 int result;
12360 PyObject * obj0 = 0 ;
12361 char *kwnames[] = {
12362 (char *) "self", NULL
12363 };
12364
12365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12367 if (SWIG_arg_fail(1)) SWIG_fail;
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 result = (int)(arg1)->GetRudderMax();
12371
12372 wxPyEndAllowThreads(__tstate);
12373 if (PyErr_Occurred()) SWIG_fail;
12374 }
12375 {
12376 resultobj = SWIG_From_int((int)(result));
12377 }
12378 return resultobj;
12379 fail:
12380 return NULL;
12381 }
12382
12383
12384 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12385 PyObject *resultobj;
12386 wxJoystick *arg1 = (wxJoystick *) 0 ;
12387 int result;
12388 PyObject * obj0 = 0 ;
12389 char *kwnames[] = {
12390 (char *) "self", NULL
12391 };
12392
12393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12395 if (SWIG_arg_fail(1)) SWIG_fail;
12396 {
12397 PyThreadState* __tstate = wxPyBeginAllowThreads();
12398 result = (int)(arg1)->GetUMin();
12399
12400 wxPyEndAllowThreads(__tstate);
12401 if (PyErr_Occurred()) SWIG_fail;
12402 }
12403 {
12404 resultobj = SWIG_From_int((int)(result));
12405 }
12406 return resultobj;
12407 fail:
12408 return NULL;
12409 }
12410
12411
12412 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12413 PyObject *resultobj;
12414 wxJoystick *arg1 = (wxJoystick *) 0 ;
12415 int result;
12416 PyObject * obj0 = 0 ;
12417 char *kwnames[] = {
12418 (char *) "self", NULL
12419 };
12420
12421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12423 if (SWIG_arg_fail(1)) SWIG_fail;
12424 {
12425 PyThreadState* __tstate = wxPyBeginAllowThreads();
12426 result = (int)(arg1)->GetUMax();
12427
12428 wxPyEndAllowThreads(__tstate);
12429 if (PyErr_Occurred()) SWIG_fail;
12430 }
12431 {
12432 resultobj = SWIG_From_int((int)(result));
12433 }
12434 return resultobj;
12435 fail:
12436 return NULL;
12437 }
12438
12439
12440 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12441 PyObject *resultobj;
12442 wxJoystick *arg1 = (wxJoystick *) 0 ;
12443 int result;
12444 PyObject * obj0 = 0 ;
12445 char *kwnames[] = {
12446 (char *) "self", NULL
12447 };
12448
12449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12451 if (SWIG_arg_fail(1)) SWIG_fail;
12452 {
12453 PyThreadState* __tstate = wxPyBeginAllowThreads();
12454 result = (int)(arg1)->GetVMin();
12455
12456 wxPyEndAllowThreads(__tstate);
12457 if (PyErr_Occurred()) SWIG_fail;
12458 }
12459 {
12460 resultobj = SWIG_From_int((int)(result));
12461 }
12462 return resultobj;
12463 fail:
12464 return NULL;
12465 }
12466
12467
12468 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12469 PyObject *resultobj;
12470 wxJoystick *arg1 = (wxJoystick *) 0 ;
12471 int result;
12472 PyObject * obj0 = 0 ;
12473 char *kwnames[] = {
12474 (char *) "self", NULL
12475 };
12476
12477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12479 if (SWIG_arg_fail(1)) SWIG_fail;
12480 {
12481 PyThreadState* __tstate = wxPyBeginAllowThreads();
12482 result = (int)(arg1)->GetVMax();
12483
12484 wxPyEndAllowThreads(__tstate);
12485 if (PyErr_Occurred()) SWIG_fail;
12486 }
12487 {
12488 resultobj = SWIG_From_int((int)(result));
12489 }
12490 return resultobj;
12491 fail:
12492 return NULL;
12493 }
12494
12495
12496 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12497 PyObject *resultobj;
12498 wxJoystick *arg1 = (wxJoystick *) 0 ;
12499 bool result;
12500 PyObject * obj0 = 0 ;
12501 char *kwnames[] = {
12502 (char *) "self", NULL
12503 };
12504
12505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12507 if (SWIG_arg_fail(1)) SWIG_fail;
12508 {
12509 PyThreadState* __tstate = wxPyBeginAllowThreads();
12510 result = (bool)(arg1)->HasRudder();
12511
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 {
12516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12517 }
12518 return resultobj;
12519 fail:
12520 return NULL;
12521 }
12522
12523
12524 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12525 PyObject *resultobj;
12526 wxJoystick *arg1 = (wxJoystick *) 0 ;
12527 bool result;
12528 PyObject * obj0 = 0 ;
12529 char *kwnames[] = {
12530 (char *) "self", NULL
12531 };
12532
12533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12535 if (SWIG_arg_fail(1)) SWIG_fail;
12536 {
12537 PyThreadState* __tstate = wxPyBeginAllowThreads();
12538 result = (bool)(arg1)->HasZ();
12539
12540 wxPyEndAllowThreads(__tstate);
12541 if (PyErr_Occurred()) SWIG_fail;
12542 }
12543 {
12544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12545 }
12546 return resultobj;
12547 fail:
12548 return NULL;
12549 }
12550
12551
12552 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12553 PyObject *resultobj;
12554 wxJoystick *arg1 = (wxJoystick *) 0 ;
12555 bool result;
12556 PyObject * obj0 = 0 ;
12557 char *kwnames[] = {
12558 (char *) "self", NULL
12559 };
12560
12561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12563 if (SWIG_arg_fail(1)) SWIG_fail;
12564 {
12565 PyThreadState* __tstate = wxPyBeginAllowThreads();
12566 result = (bool)(arg1)->HasU();
12567
12568 wxPyEndAllowThreads(__tstate);
12569 if (PyErr_Occurred()) SWIG_fail;
12570 }
12571 {
12572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12573 }
12574 return resultobj;
12575 fail:
12576 return NULL;
12577 }
12578
12579
12580 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12581 PyObject *resultobj;
12582 wxJoystick *arg1 = (wxJoystick *) 0 ;
12583 bool result;
12584 PyObject * obj0 = 0 ;
12585 char *kwnames[] = {
12586 (char *) "self", NULL
12587 };
12588
12589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12591 if (SWIG_arg_fail(1)) SWIG_fail;
12592 {
12593 PyThreadState* __tstate = wxPyBeginAllowThreads();
12594 result = (bool)(arg1)->HasV();
12595
12596 wxPyEndAllowThreads(__tstate);
12597 if (PyErr_Occurred()) SWIG_fail;
12598 }
12599 {
12600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12601 }
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12609 PyObject *resultobj;
12610 wxJoystick *arg1 = (wxJoystick *) 0 ;
12611 bool result;
12612 PyObject * obj0 = 0 ;
12613 char *kwnames[] = {
12614 (char *) "self", NULL
12615 };
12616
12617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12619 if (SWIG_arg_fail(1)) SWIG_fail;
12620 {
12621 PyThreadState* __tstate = wxPyBeginAllowThreads();
12622 result = (bool)(arg1)->HasPOV();
12623
12624 wxPyEndAllowThreads(__tstate);
12625 if (PyErr_Occurred()) SWIG_fail;
12626 }
12627 {
12628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12629 }
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj;
12638 wxJoystick *arg1 = (wxJoystick *) 0 ;
12639 bool result;
12640 PyObject * obj0 = 0 ;
12641 char *kwnames[] = {
12642 (char *) "self", NULL
12643 };
12644
12645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12647 if (SWIG_arg_fail(1)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (bool)(arg1)->HasPOV4Dir();
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 {
12656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12657 }
12658 return resultobj;
12659 fail:
12660 return NULL;
12661 }
12662
12663
12664 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12665 PyObject *resultobj;
12666 wxJoystick *arg1 = (wxJoystick *) 0 ;
12667 bool result;
12668 PyObject * obj0 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (bool)(arg1)->HasPOVCTS();
12679
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 {
12684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12685 }
12686 return resultobj;
12687 fail:
12688 return NULL;
12689 }
12690
12691
12692 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12693 PyObject *resultobj;
12694 wxJoystick *arg1 = (wxJoystick *) 0 ;
12695 wxWindow *arg2 = (wxWindow *) 0 ;
12696 int arg3 = (int) 0 ;
12697 bool result;
12698 PyObject * obj0 = 0 ;
12699 PyObject * obj1 = 0 ;
12700 PyObject * obj2 = 0 ;
12701 char *kwnames[] = {
12702 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12703 };
12704
12705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12707 if (SWIG_arg_fail(1)) SWIG_fail;
12708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12709 if (SWIG_arg_fail(2)) SWIG_fail;
12710 if (obj2) {
12711 {
12712 arg3 = (int)(SWIG_As_int(obj2));
12713 if (SWIG_arg_fail(3)) SWIG_fail;
12714 }
12715 }
12716 {
12717 PyThreadState* __tstate = wxPyBeginAllowThreads();
12718 result = (bool)(arg1)->SetCapture(arg2,arg3);
12719
12720 wxPyEndAllowThreads(__tstate);
12721 if (PyErr_Occurred()) SWIG_fail;
12722 }
12723 {
12724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12725 }
12726 return resultobj;
12727 fail:
12728 return NULL;
12729 }
12730
12731
12732 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12733 PyObject *resultobj;
12734 wxJoystick *arg1 = (wxJoystick *) 0 ;
12735 bool result;
12736 PyObject * obj0 = 0 ;
12737 char *kwnames[] = {
12738 (char *) "self", NULL
12739 };
12740
12741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12743 if (SWIG_arg_fail(1)) SWIG_fail;
12744 {
12745 PyThreadState* __tstate = wxPyBeginAllowThreads();
12746 result = (bool)(arg1)->ReleaseCapture();
12747
12748 wxPyEndAllowThreads(__tstate);
12749 if (PyErr_Occurred()) SWIG_fail;
12750 }
12751 {
12752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12753 }
12754 return resultobj;
12755 fail:
12756 return NULL;
12757 }
12758
12759
12760 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12761 PyObject *obj;
12762 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12763 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12764 Py_INCREF(obj);
12765 return Py_BuildValue((char *)"");
12766 }
12767 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12768 PyObject *resultobj;
12769 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12770 int arg2 = (int) 0 ;
12771 int arg3 = (int) wxJOYSTICK1 ;
12772 int arg4 = (int) 0 ;
12773 wxJoystickEvent *result;
12774 PyObject * obj0 = 0 ;
12775 PyObject * obj1 = 0 ;
12776 PyObject * obj2 = 0 ;
12777 PyObject * obj3 = 0 ;
12778 char *kwnames[] = {
12779 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12780 };
12781
12782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12783 if (obj0) {
12784 {
12785 arg1 = (wxEventType)(SWIG_As_int(obj0));
12786 if (SWIG_arg_fail(1)) SWIG_fail;
12787 }
12788 }
12789 if (obj1) {
12790 {
12791 arg2 = (int)(SWIG_As_int(obj1));
12792 if (SWIG_arg_fail(2)) SWIG_fail;
12793 }
12794 }
12795 if (obj2) {
12796 {
12797 arg3 = (int)(SWIG_As_int(obj2));
12798 if (SWIG_arg_fail(3)) SWIG_fail;
12799 }
12800 }
12801 if (obj3) {
12802 {
12803 arg4 = (int)(SWIG_As_int(obj3));
12804 if (SWIG_arg_fail(4)) SWIG_fail;
12805 }
12806 }
12807 {
12808 PyThreadState* __tstate = wxPyBeginAllowThreads();
12809 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12810
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12822 PyObject *resultobj;
12823 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12824 wxPoint result;
12825 PyObject * obj0 = 0 ;
12826 char *kwnames[] = {
12827 (char *) "self", NULL
12828 };
12829
12830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12832 if (SWIG_arg_fail(1)) SWIG_fail;
12833 {
12834 PyThreadState* __tstate = wxPyBeginAllowThreads();
12835 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12836
12837 wxPyEndAllowThreads(__tstate);
12838 if (PyErr_Occurred()) SWIG_fail;
12839 }
12840 {
12841 wxPoint * resultptr;
12842 resultptr = new wxPoint((wxPoint &)(result));
12843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12844 }
12845 return resultobj;
12846 fail:
12847 return NULL;
12848 }
12849
12850
12851 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12852 PyObject *resultobj;
12853 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12854 int result;
12855 PyObject * obj0 = 0 ;
12856 char *kwnames[] = {
12857 (char *) "self", NULL
12858 };
12859
12860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12862 if (SWIG_arg_fail(1)) SWIG_fail;
12863 {
12864 PyThreadState* __tstate = wxPyBeginAllowThreads();
12865 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12866
12867 wxPyEndAllowThreads(__tstate);
12868 if (PyErr_Occurred()) SWIG_fail;
12869 }
12870 {
12871 resultobj = SWIG_From_int((int)(result));
12872 }
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12880 PyObject *resultobj;
12881 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12882 int result;
12883 PyObject * obj0 = 0 ;
12884 char *kwnames[] = {
12885 (char *) "self", NULL
12886 };
12887
12888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12890 if (SWIG_arg_fail(1)) SWIG_fail;
12891 {
12892 PyThreadState* __tstate = wxPyBeginAllowThreads();
12893 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12894
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 {
12899 resultobj = SWIG_From_int((int)(result));
12900 }
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12908 PyObject *resultobj;
12909 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12910 int result;
12911 PyObject * obj0 = 0 ;
12912 char *kwnames[] = {
12913 (char *) "self", NULL
12914 };
12915
12916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12918 if (SWIG_arg_fail(1)) SWIG_fail;
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12922
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 {
12927 resultobj = SWIG_From_int((int)(result));
12928 }
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj;
12937 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12938 int result;
12939 PyObject * obj0 = 0 ;
12940 char *kwnames[] = {
12941 (char *) "self", NULL
12942 };
12943
12944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12946 if (SWIG_arg_fail(1)) SWIG_fail;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12950
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 {
12955 resultobj = SWIG_From_int((int)(result));
12956 }
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj;
12965 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12966 int arg2 ;
12967 PyObject * obj0 = 0 ;
12968 PyObject * obj1 = 0 ;
12969 char *kwnames[] = {
12970 (char *) "self",(char *) "stick", NULL
12971 };
12972
12973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12975 if (SWIG_arg_fail(1)) SWIG_fail;
12976 {
12977 arg2 = (int)(SWIG_As_int(obj1));
12978 if (SWIG_arg_fail(2)) SWIG_fail;
12979 }
12980 {
12981 PyThreadState* __tstate = wxPyBeginAllowThreads();
12982 (arg1)->SetJoystick(arg2);
12983
12984 wxPyEndAllowThreads(__tstate);
12985 if (PyErr_Occurred()) SWIG_fail;
12986 }
12987 Py_INCREF(Py_None); resultobj = Py_None;
12988 return resultobj;
12989 fail:
12990 return NULL;
12991 }
12992
12993
12994 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12995 PyObject *resultobj;
12996 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12997 int arg2 ;
12998 PyObject * obj0 = 0 ;
12999 PyObject * obj1 = 0 ;
13000 char *kwnames[] = {
13001 (char *) "self",(char *) "state", NULL
13002 };
13003
13004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13006 if (SWIG_arg_fail(1)) SWIG_fail;
13007 {
13008 arg2 = (int)(SWIG_As_int(obj1));
13009 if (SWIG_arg_fail(2)) SWIG_fail;
13010 }
13011 {
13012 PyThreadState* __tstate = wxPyBeginAllowThreads();
13013 (arg1)->SetButtonState(arg2);
13014
13015 wxPyEndAllowThreads(__tstate);
13016 if (PyErr_Occurred()) SWIG_fail;
13017 }
13018 Py_INCREF(Py_None); resultobj = Py_None;
13019 return resultobj;
13020 fail:
13021 return NULL;
13022 }
13023
13024
13025 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13026 PyObject *resultobj;
13027 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13028 int arg2 ;
13029 PyObject * obj0 = 0 ;
13030 PyObject * obj1 = 0 ;
13031 char *kwnames[] = {
13032 (char *) "self",(char *) "change", NULL
13033 };
13034
13035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13037 if (SWIG_arg_fail(1)) SWIG_fail;
13038 {
13039 arg2 = (int)(SWIG_As_int(obj1));
13040 if (SWIG_arg_fail(2)) SWIG_fail;
13041 }
13042 {
13043 PyThreadState* __tstate = wxPyBeginAllowThreads();
13044 (arg1)->SetButtonChange(arg2);
13045
13046 wxPyEndAllowThreads(__tstate);
13047 if (PyErr_Occurred()) SWIG_fail;
13048 }
13049 Py_INCREF(Py_None); resultobj = Py_None;
13050 return resultobj;
13051 fail:
13052 return NULL;
13053 }
13054
13055
13056 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13057 PyObject *resultobj;
13058 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13059 wxPoint *arg2 = 0 ;
13060 wxPoint temp2 ;
13061 PyObject * obj0 = 0 ;
13062 PyObject * obj1 = 0 ;
13063 char *kwnames[] = {
13064 (char *) "self",(char *) "pos", NULL
13065 };
13066
13067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13069 if (SWIG_arg_fail(1)) SWIG_fail;
13070 {
13071 arg2 = &temp2;
13072 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13073 }
13074 {
13075 PyThreadState* __tstate = wxPyBeginAllowThreads();
13076 (arg1)->SetPosition((wxPoint const &)*arg2);
13077
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 Py_INCREF(Py_None); resultobj = Py_None;
13082 return resultobj;
13083 fail:
13084 return NULL;
13085 }
13086
13087
13088 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13089 PyObject *resultobj;
13090 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13091 int arg2 ;
13092 PyObject * obj0 = 0 ;
13093 PyObject * obj1 = 0 ;
13094 char *kwnames[] = {
13095 (char *) "self",(char *) "zPos", NULL
13096 };
13097
13098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13100 if (SWIG_arg_fail(1)) SWIG_fail;
13101 {
13102 arg2 = (int)(SWIG_As_int(obj1));
13103 if (SWIG_arg_fail(2)) SWIG_fail;
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 (arg1)->SetZPosition(arg2);
13108
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 Py_INCREF(Py_None); resultobj = Py_None;
13113 return resultobj;
13114 fail:
13115 return NULL;
13116 }
13117
13118
13119 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13120 PyObject *resultobj;
13121 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13122 bool result;
13123 PyObject * obj0 = 0 ;
13124 char *kwnames[] = {
13125 (char *) "self", NULL
13126 };
13127
13128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13130 if (SWIG_arg_fail(1)) SWIG_fail;
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 {
13139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13140 }
13141 return resultobj;
13142 fail:
13143 return NULL;
13144 }
13145
13146
13147 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13148 PyObject *resultobj;
13149 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13150 bool result;
13151 PyObject * obj0 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "self", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 PyThreadState* __tstate = wxPyBeginAllowThreads();
13161 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13162
13163 wxPyEndAllowThreads(__tstate);
13164 if (PyErr_Occurred()) SWIG_fail;
13165 }
13166 {
13167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13168 }
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj;
13177 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13178 bool result;
13179 PyObject * obj0 = 0 ;
13180 char *kwnames[] = {
13181 (char *) "self", NULL
13182 };
13183
13184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13186 if (SWIG_arg_fail(1)) SWIG_fail;
13187 {
13188 PyThreadState* __tstate = wxPyBeginAllowThreads();
13189 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13190
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 {
13195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj;
13205 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13206 int arg2 = (int) wxJOY_BUTTON_ANY ;
13207 bool result;
13208 PyObject * obj0 = 0 ;
13209 PyObject * obj1 = 0 ;
13210 char *kwnames[] = {
13211 (char *) "self",(char *) "but", NULL
13212 };
13213
13214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13216 if (SWIG_arg_fail(1)) SWIG_fail;
13217 if (obj1) {
13218 {
13219 arg2 = (int)(SWIG_As_int(obj1));
13220 if (SWIG_arg_fail(2)) SWIG_fail;
13221 }
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13226
13227 wxPyEndAllowThreads(__tstate);
13228 if (PyErr_Occurred()) SWIG_fail;
13229 }
13230 {
13231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13232 }
13233 return resultobj;
13234 fail:
13235 return NULL;
13236 }
13237
13238
13239 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13240 PyObject *resultobj;
13241 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13242 int arg2 = (int) wxJOY_BUTTON_ANY ;
13243 bool result;
13244 PyObject * obj0 = 0 ;
13245 PyObject * obj1 = 0 ;
13246 char *kwnames[] = {
13247 (char *) "self",(char *) "but", NULL
13248 };
13249
13250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13252 if (SWIG_arg_fail(1)) SWIG_fail;
13253 if (obj1) {
13254 {
13255 arg2 = (int)(SWIG_As_int(obj1));
13256 if (SWIG_arg_fail(2)) SWIG_fail;
13257 }
13258 }
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 {
13267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13268 }
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj;
13277 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13278 int arg2 = (int) wxJOY_BUTTON_ANY ;
13279 bool result;
13280 PyObject * obj0 = 0 ;
13281 PyObject * obj1 = 0 ;
13282 char *kwnames[] = {
13283 (char *) "self",(char *) "but", NULL
13284 };
13285
13286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13288 if (SWIG_arg_fail(1)) SWIG_fail;
13289 if (obj1) {
13290 {
13291 arg2 = (int)(SWIG_As_int(obj1));
13292 if (SWIG_arg_fail(2)) SWIG_fail;
13293 }
13294 }
13295 {
13296 PyThreadState* __tstate = wxPyBeginAllowThreads();
13297 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13298
13299 wxPyEndAllowThreads(__tstate);
13300 if (PyErr_Occurred()) SWIG_fail;
13301 }
13302 {
13303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13304 }
13305 return resultobj;
13306 fail:
13307 return NULL;
13308 }
13309
13310
13311 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13312 PyObject *obj;
13313 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13314 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13315 Py_INCREF(obj);
13316 return Py_BuildValue((char *)"");
13317 }
13318 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13319 PyObject *resultobj;
13320 wxString const &arg1_defvalue = wxPyEmptyString ;
13321 wxString *arg1 = (wxString *) &arg1_defvalue ;
13322 wxSound *result;
13323 bool temp1 = false ;
13324 PyObject * obj0 = 0 ;
13325 char *kwnames[] = {
13326 (char *) "fileName", NULL
13327 };
13328
13329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13330 if (obj0) {
13331 {
13332 arg1 = wxString_in_helper(obj0);
13333 if (arg1 == NULL) SWIG_fail;
13334 temp1 = true;
13335 }
13336 }
13337 {
13338 if (!wxPyCheckForApp()) SWIG_fail;
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13341
13342 wxPyEndAllowThreads(__tstate);
13343 if (PyErr_Occurred()) SWIG_fail;
13344 }
13345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13346 {
13347 if (temp1)
13348 delete arg1;
13349 }
13350 return resultobj;
13351 fail:
13352 {
13353 if (temp1)
13354 delete arg1;
13355 }
13356 return NULL;
13357 }
13358
13359
13360 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13361 PyObject *resultobj;
13362 PyObject *arg1 = (PyObject *) 0 ;
13363 wxSound *result;
13364 PyObject * obj0 = 0 ;
13365 char *kwnames[] = {
13366 (char *) "data", NULL
13367 };
13368
13369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13370 arg1 = obj0;
13371 {
13372 if (!wxPyCheckForApp()) SWIG_fail;
13373 PyThreadState* __tstate = wxPyBeginAllowThreads();
13374 result = (wxSound *)new_wxSound(arg1);
13375
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13387 PyObject *resultobj;
13388 wxSound *arg1 = (wxSound *) 0 ;
13389 PyObject * obj0 = 0 ;
13390 char *kwnames[] = {
13391 (char *) "self", NULL
13392 };
13393
13394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13396 if (SWIG_arg_fail(1)) SWIG_fail;
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 delete arg1;
13400
13401 wxPyEndAllowThreads(__tstate);
13402 if (PyErr_Occurred()) SWIG_fail;
13403 }
13404 Py_INCREF(Py_None); resultobj = Py_None;
13405 return resultobj;
13406 fail:
13407 return NULL;
13408 }
13409
13410
13411 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13412 PyObject *resultobj;
13413 wxSound *arg1 = (wxSound *) 0 ;
13414 wxString *arg2 = 0 ;
13415 bool result;
13416 bool temp2 = false ;
13417 PyObject * obj0 = 0 ;
13418 PyObject * obj1 = 0 ;
13419 char *kwnames[] = {
13420 (char *) "self",(char *) "fileName", NULL
13421 };
13422
13423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13425 if (SWIG_arg_fail(1)) SWIG_fail;
13426 {
13427 arg2 = wxString_in_helper(obj1);
13428 if (arg2 == NULL) SWIG_fail;
13429 temp2 = true;
13430 }
13431 {
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (bool)(arg1)->Create((wxString const &)*arg2);
13434
13435 wxPyEndAllowThreads(__tstate);
13436 if (PyErr_Occurred()) SWIG_fail;
13437 }
13438 {
13439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13440 }
13441 {
13442 if (temp2)
13443 delete arg2;
13444 }
13445 return resultobj;
13446 fail:
13447 {
13448 if (temp2)
13449 delete arg2;
13450 }
13451 return NULL;
13452 }
13453
13454
13455 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13456 PyObject *resultobj;
13457 wxSound *arg1 = (wxSound *) 0 ;
13458 PyObject *arg2 = (PyObject *) 0 ;
13459 bool result;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 char *kwnames[] = {
13463 (char *) "self",(char *) "data", NULL
13464 };
13465
13466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13468 if (SWIG_arg_fail(1)) SWIG_fail;
13469 arg2 = obj1;
13470 {
13471 PyThreadState* __tstate = wxPyBeginAllowThreads();
13472 result = (bool)wxSound_CreateFromData(arg1,arg2);
13473
13474 wxPyEndAllowThreads(__tstate);
13475 if (PyErr_Occurred()) SWIG_fail;
13476 }
13477 {
13478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13479 }
13480 return resultobj;
13481 fail:
13482 return NULL;
13483 }
13484
13485
13486 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13487 PyObject *resultobj;
13488 wxSound *arg1 = (wxSound *) 0 ;
13489 bool result;
13490 PyObject * obj0 = 0 ;
13491 char *kwnames[] = {
13492 (char *) "self", NULL
13493 };
13494
13495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13497 if (SWIG_arg_fail(1)) SWIG_fail;
13498 {
13499 PyThreadState* __tstate = wxPyBeginAllowThreads();
13500 result = (bool)(arg1)->IsOk();
13501
13502 wxPyEndAllowThreads(__tstate);
13503 if (PyErr_Occurred()) SWIG_fail;
13504 }
13505 {
13506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13507 }
13508 return resultobj;
13509 fail:
13510 return NULL;
13511 }
13512
13513
13514 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj;
13516 wxSound *arg1 = (wxSound *) 0 ;
13517 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13518 bool result;
13519 PyObject * obj0 = 0 ;
13520 PyObject * obj1 = 0 ;
13521 char *kwnames[] = {
13522 (char *) "self",(char *) "flags", NULL
13523 };
13524
13525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13527 if (SWIG_arg_fail(1)) SWIG_fail;
13528 if (obj1) {
13529 {
13530 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13531 if (SWIG_arg_fail(2)) SWIG_fail;
13532 }
13533 }
13534 {
13535 if (!wxPyCheckForApp()) SWIG_fail;
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 result = (bool)((wxSound const *)arg1)->Play(arg2);
13538
13539 wxPyEndAllowThreads(__tstate);
13540 if (PyErr_Occurred()) SWIG_fail;
13541 }
13542 {
13543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13544 }
13545 return resultobj;
13546 fail:
13547 return NULL;
13548 }
13549
13550
13551 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13552 PyObject *resultobj;
13553 wxString *arg1 = 0 ;
13554 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13555 bool result;
13556 bool temp1 = false ;
13557 PyObject * obj0 = 0 ;
13558 PyObject * obj1 = 0 ;
13559 char *kwnames[] = {
13560 (char *) "filename",(char *) "flags", NULL
13561 };
13562
13563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13564 {
13565 arg1 = wxString_in_helper(obj0);
13566 if (arg1 == NULL) SWIG_fail;
13567 temp1 = true;
13568 }
13569 if (obj1) {
13570 {
13571 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13572 if (SWIG_arg_fail(2)) SWIG_fail;
13573 }
13574 }
13575 {
13576 if (!wxPyCheckForApp()) SWIG_fail;
13577 PyThreadState* __tstate = wxPyBeginAllowThreads();
13578 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13579
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 {
13584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13585 }
13586 {
13587 if (temp1)
13588 delete arg1;
13589 }
13590 return resultobj;
13591 fail:
13592 {
13593 if (temp1)
13594 delete arg1;
13595 }
13596 return NULL;
13597 }
13598
13599
13600 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13601 PyObject *resultobj;
13602 char *kwnames[] = {
13603 NULL
13604 };
13605
13606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13607 {
13608 if (!wxPyCheckForApp()) SWIG_fail;
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 wxSound::Stop();
13611
13612 wxPyEndAllowThreads(__tstate);
13613 if (PyErr_Occurred()) SWIG_fail;
13614 }
13615 Py_INCREF(Py_None); resultobj = Py_None;
13616 return resultobj;
13617 fail:
13618 return NULL;
13619 }
13620
13621
13622 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13623 PyObject *obj;
13624 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13625 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13626 Py_INCREF(obj);
13627 return Py_BuildValue((char *)"");
13628 }
13629 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13630 PyObject *resultobj;
13631 wxString *arg1 = 0 ;
13632 wxString *arg2 = 0 ;
13633 wxString *arg3 = 0 ;
13634 wxString *arg4 = 0 ;
13635 wxFileTypeInfo *result;
13636 bool temp1 = false ;
13637 bool temp2 = false ;
13638 bool temp3 = false ;
13639 bool temp4 = false ;
13640 PyObject * obj0 = 0 ;
13641 PyObject * obj1 = 0 ;
13642 PyObject * obj2 = 0 ;
13643 PyObject * obj3 = 0 ;
13644 char *kwnames[] = {
13645 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13646 };
13647
13648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13649 {
13650 arg1 = wxString_in_helper(obj0);
13651 if (arg1 == NULL) SWIG_fail;
13652 temp1 = true;
13653 }
13654 {
13655 arg2 = wxString_in_helper(obj1);
13656 if (arg2 == NULL) SWIG_fail;
13657 temp2 = true;
13658 }
13659 {
13660 arg3 = wxString_in_helper(obj2);
13661 if (arg3 == NULL) SWIG_fail;
13662 temp3 = true;
13663 }
13664 {
13665 arg4 = wxString_in_helper(obj3);
13666 if (arg4 == NULL) SWIG_fail;
13667 temp4 = true;
13668 }
13669 {
13670 PyThreadState* __tstate = wxPyBeginAllowThreads();
13671 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13672
13673 wxPyEndAllowThreads(__tstate);
13674 if (PyErr_Occurred()) SWIG_fail;
13675 }
13676 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13677 {
13678 if (temp1)
13679 delete arg1;
13680 }
13681 {
13682 if (temp2)
13683 delete arg2;
13684 }
13685 {
13686 if (temp3)
13687 delete arg3;
13688 }
13689 {
13690 if (temp4)
13691 delete arg4;
13692 }
13693 return resultobj;
13694 fail:
13695 {
13696 if (temp1)
13697 delete arg1;
13698 }
13699 {
13700 if (temp2)
13701 delete arg2;
13702 }
13703 {
13704 if (temp3)
13705 delete arg3;
13706 }
13707 {
13708 if (temp4)
13709 delete arg4;
13710 }
13711 return NULL;
13712 }
13713
13714
13715 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj;
13717 wxArrayString *arg1 = 0 ;
13718 wxFileTypeInfo *result;
13719 bool temp1 = false ;
13720 PyObject * obj0 = 0 ;
13721 char *kwnames[] = {
13722 (char *) "sArray", NULL
13723 };
13724
13725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13726 {
13727 if (! PySequence_Check(obj0)) {
13728 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13729 SWIG_fail;
13730 }
13731 arg1 = new wxArrayString;
13732 temp1 = true;
13733 int i, len=PySequence_Length(obj0);
13734 for (i=0; i<len; i++) {
13735 PyObject* item = PySequence_GetItem(obj0, i);
13736 #if wxUSE_UNICODE
13737 PyObject* str = PyObject_Unicode(item);
13738 #else
13739 PyObject* str = PyObject_Str(item);
13740 #endif
13741 if (PyErr_Occurred()) SWIG_fail;
13742 arg1->Add(Py2wxString(str));
13743 Py_DECREF(item);
13744 Py_DECREF(str);
13745 }
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13750
13751 wxPyEndAllowThreads(__tstate);
13752 if (PyErr_Occurred()) SWIG_fail;
13753 }
13754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13755 {
13756 if (temp1) delete arg1;
13757 }
13758 return resultobj;
13759 fail:
13760 {
13761 if (temp1) delete arg1;
13762 }
13763 return NULL;
13764 }
13765
13766
13767 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13768 PyObject *resultobj;
13769 wxFileTypeInfo *result;
13770 char *kwnames[] = {
13771 NULL
13772 };
13773
13774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13775 {
13776 PyThreadState* __tstate = wxPyBeginAllowThreads();
13777 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13778
13779 wxPyEndAllowThreads(__tstate);
13780 if (PyErr_Occurred()) SWIG_fail;
13781 }
13782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13783 return resultobj;
13784 fail:
13785 return NULL;
13786 }
13787
13788
13789 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13790 PyObject *resultobj;
13791 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13792 bool result;
13793 PyObject * obj0 = 0 ;
13794 char *kwnames[] = {
13795 (char *) "self", NULL
13796 };
13797
13798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13800 if (SWIG_arg_fail(1)) SWIG_fail;
13801 {
13802 PyThreadState* __tstate = wxPyBeginAllowThreads();
13803 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13804
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 {
13809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13810 }
13811 return resultobj;
13812 fail:
13813 return NULL;
13814 }
13815
13816
13817 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13818 PyObject *resultobj;
13819 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13820 wxString *arg2 = 0 ;
13821 int arg3 = (int) 0 ;
13822 bool temp2 = false ;
13823 PyObject * obj0 = 0 ;
13824 PyObject * obj1 = 0 ;
13825 PyObject * obj2 = 0 ;
13826 char *kwnames[] = {
13827 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13828 };
13829
13830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13832 if (SWIG_arg_fail(1)) SWIG_fail;
13833 {
13834 arg2 = wxString_in_helper(obj1);
13835 if (arg2 == NULL) SWIG_fail;
13836 temp2 = true;
13837 }
13838 if (obj2) {
13839 {
13840 arg3 = (int)(SWIG_As_int(obj2));
13841 if (SWIG_arg_fail(3)) SWIG_fail;
13842 }
13843 }
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13847
13848 wxPyEndAllowThreads(__tstate);
13849 if (PyErr_Occurred()) SWIG_fail;
13850 }
13851 Py_INCREF(Py_None); resultobj = Py_None;
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return resultobj;
13857 fail:
13858 {
13859 if (temp2)
13860 delete arg2;
13861 }
13862 return NULL;
13863 }
13864
13865
13866 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13867 PyObject *resultobj;
13868 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13869 wxString *arg2 = 0 ;
13870 bool temp2 = false ;
13871 PyObject * obj0 = 0 ;
13872 PyObject * obj1 = 0 ;
13873 char *kwnames[] = {
13874 (char *) "self",(char *) "shortDesc", NULL
13875 };
13876
13877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13879 if (SWIG_arg_fail(1)) SWIG_fail;
13880 {
13881 arg2 = wxString_in_helper(obj1);
13882 if (arg2 == NULL) SWIG_fail;
13883 temp2 = true;
13884 }
13885 {
13886 PyThreadState* __tstate = wxPyBeginAllowThreads();
13887 (arg1)->SetShortDesc((wxString const &)*arg2);
13888
13889 wxPyEndAllowThreads(__tstate);
13890 if (PyErr_Occurred()) SWIG_fail;
13891 }
13892 Py_INCREF(Py_None); resultobj = Py_None;
13893 {
13894 if (temp2)
13895 delete arg2;
13896 }
13897 return resultobj;
13898 fail:
13899 {
13900 if (temp2)
13901 delete arg2;
13902 }
13903 return NULL;
13904 }
13905
13906
13907 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13908 PyObject *resultobj;
13909 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13910 wxString *result;
13911 PyObject * obj0 = 0 ;
13912 char *kwnames[] = {
13913 (char *) "self", NULL
13914 };
13915
13916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13918 if (SWIG_arg_fail(1)) SWIG_fail;
13919 {
13920 PyThreadState* __tstate = wxPyBeginAllowThreads();
13921 {
13922 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13923 result = (wxString *) &_result_ref;
13924 }
13925
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 {
13930 #if wxUSE_UNICODE
13931 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13932 #else
13933 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13934 #endif
13935 }
13936 return resultobj;
13937 fail:
13938 return NULL;
13939 }
13940
13941
13942 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13943 PyObject *resultobj;
13944 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13945 wxString *result;
13946 PyObject * obj0 = 0 ;
13947 char *kwnames[] = {
13948 (char *) "self", NULL
13949 };
13950
13951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13953 if (SWIG_arg_fail(1)) SWIG_fail;
13954 {
13955 PyThreadState* __tstate = wxPyBeginAllowThreads();
13956 {
13957 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13958 result = (wxString *) &_result_ref;
13959 }
13960
13961 wxPyEndAllowThreads(__tstate);
13962 if (PyErr_Occurred()) SWIG_fail;
13963 }
13964 {
13965 #if wxUSE_UNICODE
13966 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13967 #else
13968 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13969 #endif
13970 }
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj;
13979 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13980 wxString *result;
13981 PyObject * obj0 = 0 ;
13982 char *kwnames[] = {
13983 (char *) "self", NULL
13984 };
13985
13986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13988 if (SWIG_arg_fail(1)) SWIG_fail;
13989 {
13990 PyThreadState* __tstate = wxPyBeginAllowThreads();
13991 {
13992 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13993 result = (wxString *) &_result_ref;
13994 }
13995
13996 wxPyEndAllowThreads(__tstate);
13997 if (PyErr_Occurred()) SWIG_fail;
13998 }
13999 {
14000 #if wxUSE_UNICODE
14001 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14002 #else
14003 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14004 #endif
14005 }
14006 return resultobj;
14007 fail:
14008 return NULL;
14009 }
14010
14011
14012 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14013 PyObject *resultobj;
14014 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14015 wxString *result;
14016 PyObject * obj0 = 0 ;
14017 char *kwnames[] = {
14018 (char *) "self", NULL
14019 };
14020
14021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14023 if (SWIG_arg_fail(1)) SWIG_fail;
14024 {
14025 PyThreadState* __tstate = wxPyBeginAllowThreads();
14026 {
14027 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14028 result = (wxString *) &_result_ref;
14029 }
14030
14031 wxPyEndAllowThreads(__tstate);
14032 if (PyErr_Occurred()) SWIG_fail;
14033 }
14034 {
14035 #if wxUSE_UNICODE
14036 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14037 #else
14038 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14039 #endif
14040 }
14041 return resultobj;
14042 fail:
14043 return NULL;
14044 }
14045
14046
14047 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14048 PyObject *resultobj;
14049 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14050 wxString *result;
14051 PyObject * obj0 = 0 ;
14052 char *kwnames[] = {
14053 (char *) "self", NULL
14054 };
14055
14056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14058 if (SWIG_arg_fail(1)) SWIG_fail;
14059 {
14060 PyThreadState* __tstate = wxPyBeginAllowThreads();
14061 {
14062 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14063 result = (wxString *) &_result_ref;
14064 }
14065
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 {
14070 #if wxUSE_UNICODE
14071 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14072 #else
14073 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14074 #endif
14075 }
14076 return resultobj;
14077 fail:
14078 return NULL;
14079 }
14080
14081
14082 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj;
14084 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14085 wxArrayString *result;
14086 PyObject * obj0 = 0 ;
14087 char *kwnames[] = {
14088 (char *) "self", NULL
14089 };
14090
14091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14093 if (SWIG_arg_fail(1)) SWIG_fail;
14094 {
14095 PyThreadState* __tstate = wxPyBeginAllowThreads();
14096 {
14097 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14098 result = (wxArrayString *) &_result_ref;
14099 }
14100
14101 wxPyEndAllowThreads(__tstate);
14102 if (PyErr_Occurred()) SWIG_fail;
14103 }
14104 {
14105 resultobj = wxArrayString2PyList_helper(*result);
14106 }
14107 return resultobj;
14108 fail:
14109 return NULL;
14110 }
14111
14112
14113 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14114 PyObject *resultobj;
14115 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14116 int result;
14117 PyObject * obj0 = 0 ;
14118 char *kwnames[] = {
14119 (char *) "self", NULL
14120 };
14121
14122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14124 if (SWIG_arg_fail(1)) SWIG_fail;
14125 {
14126 PyThreadState* __tstate = wxPyBeginAllowThreads();
14127 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14128
14129 wxPyEndAllowThreads(__tstate);
14130 if (PyErr_Occurred()) SWIG_fail;
14131 }
14132 {
14133 resultobj = SWIG_From_int((int)(result));
14134 }
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj;
14143 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14144 wxString *result;
14145 PyObject * obj0 = 0 ;
14146 char *kwnames[] = {
14147 (char *) "self", NULL
14148 };
14149
14150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14152 if (SWIG_arg_fail(1)) SWIG_fail;
14153 {
14154 PyThreadState* __tstate = wxPyBeginAllowThreads();
14155 {
14156 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14157 result = (wxString *) &_result_ref;
14158 }
14159
14160 wxPyEndAllowThreads(__tstate);
14161 if (PyErr_Occurred()) SWIG_fail;
14162 }
14163 {
14164 #if wxUSE_UNICODE
14165 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14166 #else
14167 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14168 #endif
14169 }
14170 return resultobj;
14171 fail:
14172 return NULL;
14173 }
14174
14175
14176 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14177 PyObject *resultobj;
14178 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14179 int result;
14180 PyObject * obj0 = 0 ;
14181 char *kwnames[] = {
14182 (char *) "self", NULL
14183 };
14184
14185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14187 if (SWIG_arg_fail(1)) SWIG_fail;
14188 {
14189 PyThreadState* __tstate = wxPyBeginAllowThreads();
14190 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14191
14192 wxPyEndAllowThreads(__tstate);
14193 if (PyErr_Occurred()) SWIG_fail;
14194 }
14195 {
14196 resultobj = SWIG_From_int((int)(result));
14197 }
14198 return resultobj;
14199 fail:
14200 return NULL;
14201 }
14202
14203
14204 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14205 PyObject *obj;
14206 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14207 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14208 Py_INCREF(obj);
14209 return Py_BuildValue((char *)"");
14210 }
14211 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj;
14213 wxFileTypeInfo *arg1 = 0 ;
14214 wxFileType *result;
14215 PyObject * obj0 = 0 ;
14216 char *kwnames[] = {
14217 (char *) "ftInfo", NULL
14218 };
14219
14220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14221 {
14222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14223 if (SWIG_arg_fail(1)) SWIG_fail;
14224 if (arg1 == NULL) {
14225 SWIG_null_ref("wxFileTypeInfo");
14226 }
14227 if (SWIG_arg_fail(1)) SWIG_fail;
14228 }
14229 {
14230 PyThreadState* __tstate = wxPyBeginAllowThreads();
14231 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14232
14233 wxPyEndAllowThreads(__tstate);
14234 if (PyErr_Occurred()) SWIG_fail;
14235 }
14236 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14237 return resultobj;
14238 fail:
14239 return NULL;
14240 }
14241
14242
14243 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14244 PyObject *resultobj;
14245 wxFileType *arg1 = (wxFileType *) 0 ;
14246 PyObject * obj0 = 0 ;
14247 char *kwnames[] = {
14248 (char *) "self", NULL
14249 };
14250
14251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14253 if (SWIG_arg_fail(1)) SWIG_fail;
14254 {
14255 PyThreadState* __tstate = wxPyBeginAllowThreads();
14256 delete arg1;
14257
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 Py_INCREF(Py_None); resultobj = Py_None;
14262 return resultobj;
14263 fail:
14264 return NULL;
14265 }
14266
14267
14268 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj;
14270 wxFileType *arg1 = (wxFileType *) 0 ;
14271 PyObject *result;
14272 PyObject * obj0 = 0 ;
14273 char *kwnames[] = {
14274 (char *) "self", NULL
14275 };
14276
14277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14279 if (SWIG_arg_fail(1)) SWIG_fail;
14280 {
14281 PyThreadState* __tstate = wxPyBeginAllowThreads();
14282 result = (PyObject *)wxFileType_GetMimeType(arg1);
14283
14284 wxPyEndAllowThreads(__tstate);
14285 if (PyErr_Occurred()) SWIG_fail;
14286 }
14287 resultobj = result;
14288 return resultobj;
14289 fail:
14290 return NULL;
14291 }
14292
14293
14294 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14295 PyObject *resultobj;
14296 wxFileType *arg1 = (wxFileType *) 0 ;
14297 PyObject *result;
14298 PyObject * obj0 = 0 ;
14299 char *kwnames[] = {
14300 (char *) "self", NULL
14301 };
14302
14303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14305 if (SWIG_arg_fail(1)) SWIG_fail;
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14309
14310 wxPyEndAllowThreads(__tstate);
14311 if (PyErr_Occurred()) SWIG_fail;
14312 }
14313 resultobj = result;
14314 return resultobj;
14315 fail:
14316 return NULL;
14317 }
14318
14319
14320 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14321 PyObject *resultobj;
14322 wxFileType *arg1 = (wxFileType *) 0 ;
14323 PyObject *result;
14324 PyObject * obj0 = 0 ;
14325 char *kwnames[] = {
14326 (char *) "self", NULL
14327 };
14328
14329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14331 if (SWIG_arg_fail(1)) SWIG_fail;
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (PyObject *)wxFileType_GetExtensions(arg1);
14335
14336 wxPyEndAllowThreads(__tstate);
14337 if (PyErr_Occurred()) SWIG_fail;
14338 }
14339 resultobj = result;
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14347 PyObject *resultobj;
14348 wxFileType *arg1 = (wxFileType *) 0 ;
14349 wxIcon *result;
14350 PyObject * obj0 = 0 ;
14351 char *kwnames[] = {
14352 (char *) "self", NULL
14353 };
14354
14355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14357 if (SWIG_arg_fail(1)) SWIG_fail;
14358 {
14359 PyThreadState* __tstate = wxPyBeginAllowThreads();
14360 result = (wxIcon *)wxFileType_GetIcon(arg1);
14361
14362 wxPyEndAllowThreads(__tstate);
14363 if (PyErr_Occurred()) SWIG_fail;
14364 }
14365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj;
14374 wxFileType *arg1 = (wxFileType *) 0 ;
14375 PyObject *result;
14376 PyObject * obj0 = 0 ;
14377 char *kwnames[] = {
14378 (char *) "self", NULL
14379 };
14380
14381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14383 if (SWIG_arg_fail(1)) SWIG_fail;
14384 {
14385 PyThreadState* __tstate = wxPyBeginAllowThreads();
14386 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14387
14388 wxPyEndAllowThreads(__tstate);
14389 if (PyErr_Occurred()) SWIG_fail;
14390 }
14391 resultobj = result;
14392 return resultobj;
14393 fail:
14394 return NULL;
14395 }
14396
14397
14398 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14399 PyObject *resultobj;
14400 wxFileType *arg1 = (wxFileType *) 0 ;
14401 PyObject *result;
14402 PyObject * obj0 = 0 ;
14403 char *kwnames[] = {
14404 (char *) "self", NULL
14405 };
14406
14407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14409 if (SWIG_arg_fail(1)) SWIG_fail;
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (PyObject *)wxFileType_GetDescription(arg1);
14413
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = result;
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14425 PyObject *resultobj;
14426 wxFileType *arg1 = (wxFileType *) 0 ;
14427 wxString *arg2 = 0 ;
14428 wxString const &arg3_defvalue = wxPyEmptyString ;
14429 wxString *arg3 = (wxString *) &arg3_defvalue ;
14430 PyObject *result;
14431 bool temp2 = false ;
14432 bool temp3 = false ;
14433 PyObject * obj0 = 0 ;
14434 PyObject * obj1 = 0 ;
14435 PyObject * obj2 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 arg2 = wxString_in_helper(obj1);
14445 if (arg2 == NULL) SWIG_fail;
14446 temp2 = true;
14447 }
14448 if (obj2) {
14449 {
14450 arg3 = wxString_in_helper(obj2);
14451 if (arg3 == NULL) SWIG_fail;
14452 temp3 = true;
14453 }
14454 }
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14458
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 resultobj = result;
14463 {
14464 if (temp2)
14465 delete arg2;
14466 }
14467 {
14468 if (temp3)
14469 delete arg3;
14470 }
14471 return resultobj;
14472 fail:
14473 {
14474 if (temp2)
14475 delete arg2;
14476 }
14477 {
14478 if (temp3)
14479 delete arg3;
14480 }
14481 return NULL;
14482 }
14483
14484
14485 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14486 PyObject *resultobj;
14487 wxFileType *arg1 = (wxFileType *) 0 ;
14488 wxString *arg2 = 0 ;
14489 wxString const &arg3_defvalue = wxPyEmptyString ;
14490 wxString *arg3 = (wxString *) &arg3_defvalue ;
14491 PyObject *result;
14492 bool temp2 = false ;
14493 bool temp3 = false ;
14494 PyObject * obj0 = 0 ;
14495 PyObject * obj1 = 0 ;
14496 PyObject * obj2 = 0 ;
14497 char *kwnames[] = {
14498 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14499 };
14500
14501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14503 if (SWIG_arg_fail(1)) SWIG_fail;
14504 {
14505 arg2 = wxString_in_helper(obj1);
14506 if (arg2 == NULL) SWIG_fail;
14507 temp2 = true;
14508 }
14509 if (obj2) {
14510 {
14511 arg3 = wxString_in_helper(obj2);
14512 if (arg3 == NULL) SWIG_fail;
14513 temp3 = true;
14514 }
14515 }
14516 {
14517 PyThreadState* __tstate = wxPyBeginAllowThreads();
14518 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14519
14520 wxPyEndAllowThreads(__tstate);
14521 if (PyErr_Occurred()) SWIG_fail;
14522 }
14523 resultobj = result;
14524 {
14525 if (temp2)
14526 delete arg2;
14527 }
14528 {
14529 if (temp3)
14530 delete arg3;
14531 }
14532 return resultobj;
14533 fail:
14534 {
14535 if (temp2)
14536 delete arg2;
14537 }
14538 {
14539 if (temp3)
14540 delete arg3;
14541 }
14542 return NULL;
14543 }
14544
14545
14546 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14547 PyObject *resultobj;
14548 wxFileType *arg1 = (wxFileType *) 0 ;
14549 wxString *arg2 = 0 ;
14550 wxString const &arg3_defvalue = wxPyEmptyString ;
14551 wxString *arg3 = (wxString *) &arg3_defvalue ;
14552 PyObject *result;
14553 bool temp2 = false ;
14554 bool temp3 = false ;
14555 PyObject * obj0 = 0 ;
14556 PyObject * obj1 = 0 ;
14557 PyObject * obj2 = 0 ;
14558 char *kwnames[] = {
14559 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14560 };
14561
14562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 {
14566 arg2 = wxString_in_helper(obj1);
14567 if (arg2 == NULL) SWIG_fail;
14568 temp2 = true;
14569 }
14570 if (obj2) {
14571 {
14572 arg3 = wxString_in_helper(obj2);
14573 if (arg3 == NULL) SWIG_fail;
14574 temp3 = true;
14575 }
14576 }
14577 {
14578 PyThreadState* __tstate = wxPyBeginAllowThreads();
14579 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14580
14581 wxPyEndAllowThreads(__tstate);
14582 if (PyErr_Occurred()) SWIG_fail;
14583 }
14584 resultobj = result;
14585 {
14586 if (temp2)
14587 delete arg2;
14588 }
14589 {
14590 if (temp3)
14591 delete arg3;
14592 }
14593 return resultobj;
14594 fail:
14595 {
14596 if (temp2)
14597 delete arg2;
14598 }
14599 {
14600 if (temp3)
14601 delete arg3;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj;
14609 wxFileType *arg1 = (wxFileType *) 0 ;
14610 wxString *arg2 = 0 ;
14611 wxString *arg3 = 0 ;
14612 bool arg4 = (bool) true ;
14613 bool result;
14614 bool temp2 = false ;
14615 bool temp3 = false ;
14616 PyObject * obj0 = 0 ;
14617 PyObject * obj1 = 0 ;
14618 PyObject * obj2 = 0 ;
14619 PyObject * obj3 = 0 ;
14620 char *kwnames[] = {
14621 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14622 };
14623
14624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14626 if (SWIG_arg_fail(1)) SWIG_fail;
14627 {
14628 arg2 = wxString_in_helper(obj1);
14629 if (arg2 == NULL) SWIG_fail;
14630 temp2 = true;
14631 }
14632 {
14633 arg3 = wxString_in_helper(obj2);
14634 if (arg3 == NULL) SWIG_fail;
14635 temp3 = true;
14636 }
14637 if (obj3) {
14638 {
14639 arg4 = (bool)(SWIG_As_bool(obj3));
14640 if (SWIG_arg_fail(4)) SWIG_fail;
14641 }
14642 }
14643 {
14644 PyThreadState* __tstate = wxPyBeginAllowThreads();
14645 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14646
14647 wxPyEndAllowThreads(__tstate);
14648 if (PyErr_Occurred()) SWIG_fail;
14649 }
14650 {
14651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14652 }
14653 {
14654 if (temp2)
14655 delete arg2;
14656 }
14657 {
14658 if (temp3)
14659 delete arg3;
14660 }
14661 return resultobj;
14662 fail:
14663 {
14664 if (temp2)
14665 delete arg2;
14666 }
14667 {
14668 if (temp3)
14669 delete arg3;
14670 }
14671 return NULL;
14672 }
14673
14674
14675 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj;
14677 wxFileType *arg1 = (wxFileType *) 0 ;
14678 wxString const &arg2_defvalue = wxPyEmptyString ;
14679 wxString *arg2 = (wxString *) &arg2_defvalue ;
14680 int arg3 = (int) 0 ;
14681 bool result;
14682 bool temp2 = false ;
14683 PyObject * obj0 = 0 ;
14684 PyObject * obj1 = 0 ;
14685 PyObject * obj2 = 0 ;
14686 char *kwnames[] = {
14687 (char *) "self",(char *) "cmd",(char *) "index", NULL
14688 };
14689
14690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14692 if (SWIG_arg_fail(1)) SWIG_fail;
14693 if (obj1) {
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 }
14700 if (obj2) {
14701 {
14702 arg3 = (int)(SWIG_As_int(obj2));
14703 if (SWIG_arg_fail(3)) SWIG_fail;
14704 }
14705 }
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14709
14710 wxPyEndAllowThreads(__tstate);
14711 if (PyErr_Occurred()) SWIG_fail;
14712 }
14713 {
14714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14715 }
14716 {
14717 if (temp2)
14718 delete arg2;
14719 }
14720 return resultobj;
14721 fail:
14722 {
14723 if (temp2)
14724 delete arg2;
14725 }
14726 return NULL;
14727 }
14728
14729
14730 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14731 PyObject *resultobj;
14732 wxFileType *arg1 = (wxFileType *) 0 ;
14733 bool result;
14734 PyObject * obj0 = 0 ;
14735 char *kwnames[] = {
14736 (char *) "self", NULL
14737 };
14738
14739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14741 if (SWIG_arg_fail(1)) SWIG_fail;
14742 {
14743 PyThreadState* __tstate = wxPyBeginAllowThreads();
14744 result = (bool)(arg1)->Unassociate();
14745
14746 wxPyEndAllowThreads(__tstate);
14747 if (PyErr_Occurred()) SWIG_fail;
14748 }
14749 {
14750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14751 }
14752 return resultobj;
14753 fail:
14754 return NULL;
14755 }
14756
14757
14758 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14759 PyObject *resultobj;
14760 wxString *arg1 = 0 ;
14761 wxString *arg2 = 0 ;
14762 wxString const &arg3_defvalue = wxPyEmptyString ;
14763 wxString *arg3 = (wxString *) &arg3_defvalue ;
14764 wxString result;
14765 bool temp1 = false ;
14766 bool temp2 = false ;
14767 bool temp3 = false ;
14768 PyObject * obj0 = 0 ;
14769 PyObject * obj1 = 0 ;
14770 PyObject * obj2 = 0 ;
14771 char *kwnames[] = {
14772 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14773 };
14774
14775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14776 {
14777 arg1 = wxString_in_helper(obj0);
14778 if (arg1 == NULL) SWIG_fail;
14779 temp1 = true;
14780 }
14781 {
14782 arg2 = wxString_in_helper(obj1);
14783 if (arg2 == NULL) SWIG_fail;
14784 temp2 = true;
14785 }
14786 if (obj2) {
14787 {
14788 arg3 = wxString_in_helper(obj2);
14789 if (arg3 == NULL) SWIG_fail;
14790 temp3 = true;
14791 }
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14796
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 {
14801 #if wxUSE_UNICODE
14802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14803 #else
14804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14805 #endif
14806 }
14807 {
14808 if (temp1)
14809 delete arg1;
14810 }
14811 {
14812 if (temp2)
14813 delete arg2;
14814 }
14815 {
14816 if (temp3)
14817 delete arg3;
14818 }
14819 return resultobj;
14820 fail:
14821 {
14822 if (temp1)
14823 delete arg1;
14824 }
14825 {
14826 if (temp2)
14827 delete arg2;
14828 }
14829 {
14830 if (temp3)
14831 delete arg3;
14832 }
14833 return NULL;
14834 }
14835
14836
14837 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14838 PyObject *obj;
14839 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14840 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14841 Py_INCREF(obj);
14842 return Py_BuildValue((char *)"");
14843 }
14844 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14845 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14846 return 1;
14847 }
14848
14849
14850 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14851 PyObject *pyobj;
14852
14853 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14854 return pyobj;
14855 }
14856
14857
14858 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14859 PyObject *resultobj;
14860 wxString *arg1 = 0 ;
14861 wxString *arg2 = 0 ;
14862 bool result;
14863 bool temp1 = false ;
14864 bool temp2 = false ;
14865 PyObject * obj0 = 0 ;
14866 PyObject * obj1 = 0 ;
14867 char *kwnames[] = {
14868 (char *) "mimeType",(char *) "wildcard", NULL
14869 };
14870
14871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14872 {
14873 arg1 = wxString_in_helper(obj0);
14874 if (arg1 == NULL) SWIG_fail;
14875 temp1 = true;
14876 }
14877 {
14878 arg2 = wxString_in_helper(obj1);
14879 if (arg2 == NULL) SWIG_fail;
14880 temp2 = true;
14881 }
14882 {
14883 PyThreadState* __tstate = wxPyBeginAllowThreads();
14884 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14885
14886 wxPyEndAllowThreads(__tstate);
14887 if (PyErr_Occurred()) SWIG_fail;
14888 }
14889 {
14890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14891 }
14892 {
14893 if (temp1)
14894 delete arg1;
14895 }
14896 {
14897 if (temp2)
14898 delete arg2;
14899 }
14900 return resultobj;
14901 fail:
14902 {
14903 if (temp1)
14904 delete arg1;
14905 }
14906 {
14907 if (temp2)
14908 delete arg2;
14909 }
14910 return NULL;
14911 }
14912
14913
14914 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14915 PyObject *resultobj;
14916 wxMimeTypesManager *result;
14917 char *kwnames[] = {
14918 NULL
14919 };
14920
14921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14922 {
14923 PyThreadState* __tstate = wxPyBeginAllowThreads();
14924 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14925
14926 wxPyEndAllowThreads(__tstate);
14927 if (PyErr_Occurred()) SWIG_fail;
14928 }
14929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14930 return resultobj;
14931 fail:
14932 return NULL;
14933 }
14934
14935
14936 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj;
14938 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14939 int arg2 = (int) wxMAILCAP_ALL ;
14940 wxString const &arg3_defvalue = wxPyEmptyString ;
14941 wxString *arg3 = (wxString *) &arg3_defvalue ;
14942 bool temp3 = false ;
14943 PyObject * obj0 = 0 ;
14944 PyObject * obj1 = 0 ;
14945 PyObject * obj2 = 0 ;
14946 char *kwnames[] = {
14947 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14948 };
14949
14950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14952 if (SWIG_arg_fail(1)) SWIG_fail;
14953 if (obj1) {
14954 {
14955 arg2 = (int)(SWIG_As_int(obj1));
14956 if (SWIG_arg_fail(2)) SWIG_fail;
14957 }
14958 }
14959 if (obj2) {
14960 {
14961 arg3 = wxString_in_helper(obj2);
14962 if (arg3 == NULL) SWIG_fail;
14963 temp3 = true;
14964 }
14965 }
14966 {
14967 PyThreadState* __tstate = wxPyBeginAllowThreads();
14968 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14969
14970 wxPyEndAllowThreads(__tstate);
14971 if (PyErr_Occurred()) SWIG_fail;
14972 }
14973 Py_INCREF(Py_None); resultobj = Py_None;
14974 {
14975 if (temp3)
14976 delete arg3;
14977 }
14978 return resultobj;
14979 fail:
14980 {
14981 if (temp3)
14982 delete arg3;
14983 }
14984 return NULL;
14985 }
14986
14987
14988 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj;
14990 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14991 PyObject * obj0 = 0 ;
14992 char *kwnames[] = {
14993 (char *) "self", NULL
14994 };
14995
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14998 if (SWIG_arg_fail(1)) SWIG_fail;
14999 {
15000 PyThreadState* __tstate = wxPyBeginAllowThreads();
15001 (arg1)->ClearData();
15002
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 Py_INCREF(Py_None); resultobj = Py_None;
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15014 PyObject *resultobj;
15015 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15016 wxString *arg2 = 0 ;
15017 wxFileType *result;
15018 bool temp2 = false ;
15019 PyObject * obj0 = 0 ;
15020 PyObject * obj1 = 0 ;
15021 char *kwnames[] = {
15022 (char *) "self",(char *) "ext", NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15027 if (SWIG_arg_fail(1)) SWIG_fail;
15028 {
15029 arg2 = wxString_in_helper(obj1);
15030 if (arg2 == NULL) SWIG_fail;
15031 temp2 = true;
15032 }
15033 {
15034 PyThreadState* __tstate = wxPyBeginAllowThreads();
15035 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15036
15037 wxPyEndAllowThreads(__tstate);
15038 if (PyErr_Occurred()) SWIG_fail;
15039 }
15040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15041 {
15042 if (temp2)
15043 delete arg2;
15044 }
15045 return resultobj;
15046 fail:
15047 {
15048 if (temp2)
15049 delete arg2;
15050 }
15051 return NULL;
15052 }
15053
15054
15055 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15056 PyObject *resultobj;
15057 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15058 wxString *arg2 = 0 ;
15059 wxFileType *result;
15060 bool temp2 = false ;
15061 PyObject * obj0 = 0 ;
15062 PyObject * obj1 = 0 ;
15063 char *kwnames[] = {
15064 (char *) "self",(char *) "mimeType", NULL
15065 };
15066
15067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15069 if (SWIG_arg_fail(1)) SWIG_fail;
15070 {
15071 arg2 = wxString_in_helper(obj1);
15072 if (arg2 == NULL) SWIG_fail;
15073 temp2 = true;
15074 }
15075 {
15076 PyThreadState* __tstate = wxPyBeginAllowThreads();
15077 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15078
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15083 {
15084 if (temp2)
15085 delete arg2;
15086 }
15087 return resultobj;
15088 fail:
15089 {
15090 if (temp2)
15091 delete arg2;
15092 }
15093 return NULL;
15094 }
15095
15096
15097 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15098 PyObject *resultobj;
15099 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15100 wxString *arg2 = 0 ;
15101 bool arg3 = (bool) false ;
15102 bool result;
15103 bool temp2 = false ;
15104 PyObject * obj0 = 0 ;
15105 PyObject * obj1 = 0 ;
15106 PyObject * obj2 = 0 ;
15107 char *kwnames[] = {
15108 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15109 };
15110
15111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15113 if (SWIG_arg_fail(1)) SWIG_fail;
15114 {
15115 arg2 = wxString_in_helper(obj1);
15116 if (arg2 == NULL) SWIG_fail;
15117 temp2 = true;
15118 }
15119 if (obj2) {
15120 {
15121 arg3 = (bool)(SWIG_As_bool(obj2));
15122 if (SWIG_arg_fail(3)) SWIG_fail;
15123 }
15124 }
15125 {
15126 PyThreadState* __tstate = wxPyBeginAllowThreads();
15127 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15128
15129 wxPyEndAllowThreads(__tstate);
15130 if (PyErr_Occurred()) SWIG_fail;
15131 }
15132 {
15133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15134 }
15135 {
15136 if (temp2)
15137 delete arg2;
15138 }
15139 return resultobj;
15140 fail:
15141 {
15142 if (temp2)
15143 delete arg2;
15144 }
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15152 wxString *arg2 = 0 ;
15153 bool result;
15154 bool temp2 = false ;
15155 PyObject * obj0 = 0 ;
15156 PyObject * obj1 = 0 ;
15157 char *kwnames[] = {
15158 (char *) "self",(char *) "filename", NULL
15159 };
15160
15161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15163 if (SWIG_arg_fail(1)) SWIG_fail;
15164 {
15165 arg2 = wxString_in_helper(obj1);
15166 if (arg2 == NULL) SWIG_fail;
15167 temp2 = true;
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15172
15173 wxPyEndAllowThreads(__tstate);
15174 if (PyErr_Occurred()) SWIG_fail;
15175 }
15176 {
15177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15178 }
15179 {
15180 if (temp2)
15181 delete arg2;
15182 }
15183 return resultobj;
15184 fail:
15185 {
15186 if (temp2)
15187 delete arg2;
15188 }
15189 return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj;
15195 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15196 PyObject *result;
15197 PyObject * obj0 = 0 ;
15198 char *kwnames[] = {
15199 (char *) "self", NULL
15200 };
15201
15202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15204 if (SWIG_arg_fail(1)) SWIG_fail;
15205 {
15206 PyThreadState* __tstate = wxPyBeginAllowThreads();
15207 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15208
15209 wxPyEndAllowThreads(__tstate);
15210 if (PyErr_Occurred()) SWIG_fail;
15211 }
15212 resultobj = result;
15213 return resultobj;
15214 fail:
15215 return NULL;
15216 }
15217
15218
15219 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15220 PyObject *resultobj;
15221 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15222 wxFileTypeInfo *arg2 = 0 ;
15223 PyObject * obj0 = 0 ;
15224 PyObject * obj1 = 0 ;
15225 char *kwnames[] = {
15226 (char *) "self",(char *) "ft", NULL
15227 };
15228
15229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15231 if (SWIG_arg_fail(1)) SWIG_fail;
15232 {
15233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15234 if (SWIG_arg_fail(2)) SWIG_fail;
15235 if (arg2 == NULL) {
15236 SWIG_null_ref("wxFileTypeInfo");
15237 }
15238 if (SWIG_arg_fail(2)) SWIG_fail;
15239 }
15240 {
15241 PyThreadState* __tstate = wxPyBeginAllowThreads();
15242 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15243
15244 wxPyEndAllowThreads(__tstate);
15245 if (PyErr_Occurred()) SWIG_fail;
15246 }
15247 Py_INCREF(Py_None); resultobj = Py_None;
15248 return resultobj;
15249 fail:
15250 return NULL;
15251 }
15252
15253
15254 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15255 PyObject *resultobj;
15256 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15257 wxFileTypeInfo *arg2 = 0 ;
15258 wxFileType *result;
15259 PyObject * obj0 = 0 ;
15260 PyObject * obj1 = 0 ;
15261 char *kwnames[] = {
15262 (char *) "self",(char *) "ftInfo", NULL
15263 };
15264
15265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15267 if (SWIG_arg_fail(1)) SWIG_fail;
15268 {
15269 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15270 if (SWIG_arg_fail(2)) SWIG_fail;
15271 if (arg2 == NULL) {
15272 SWIG_null_ref("wxFileTypeInfo");
15273 }
15274 if (SWIG_arg_fail(2)) SWIG_fail;
15275 }
15276 {
15277 PyThreadState* __tstate = wxPyBeginAllowThreads();
15278 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15279
15280 wxPyEndAllowThreads(__tstate);
15281 if (PyErr_Occurred()) SWIG_fail;
15282 }
15283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15284 return resultobj;
15285 fail:
15286 return NULL;
15287 }
15288
15289
15290 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15291 PyObject *resultobj;
15292 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15293 wxFileType *arg2 = (wxFileType *) 0 ;
15294 bool result;
15295 PyObject * obj0 = 0 ;
15296 PyObject * obj1 = 0 ;
15297 char *kwnames[] = {
15298 (char *) "self",(char *) "ft", NULL
15299 };
15300
15301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15303 if (SWIG_arg_fail(1)) SWIG_fail;
15304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15305 if (SWIG_arg_fail(2)) SWIG_fail;
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (bool)(arg1)->Unassociate(arg2);
15309
15310 wxPyEndAllowThreads(__tstate);
15311 if (PyErr_Occurred()) SWIG_fail;
15312 }
15313 {
15314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15315 }
15316 return resultobj;
15317 fail:
15318 return NULL;
15319 }
15320
15321
15322 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15323 PyObject *resultobj;
15324 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15325 PyObject * obj0 = 0 ;
15326 char *kwnames[] = {
15327 (char *) "self", NULL
15328 };
15329
15330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15332 if (SWIG_arg_fail(1)) SWIG_fail;
15333 {
15334 PyThreadState* __tstate = wxPyBeginAllowThreads();
15335 delete arg1;
15336
15337 wxPyEndAllowThreads(__tstate);
15338 if (PyErr_Occurred()) SWIG_fail;
15339 }
15340 Py_INCREF(Py_None); resultobj = Py_None;
15341 return resultobj;
15342 fail:
15343 return NULL;
15344 }
15345
15346
15347 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15348 PyObject *obj;
15349 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15350 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15351 Py_INCREF(obj);
15352 return Py_BuildValue((char *)"");
15353 }
15354 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15355 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15356 return 1;
15357 }
15358
15359
15360 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15361 PyObject *pyobj;
15362
15363 {
15364 #if wxUSE_UNICODE
15365 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15366 #else
15367 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15368 #endif
15369 }
15370 return pyobj;
15371 }
15372
15373
15374 static int _wrap_ART_MENU_set(PyObject *) {
15375 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15376 return 1;
15377 }
15378
15379
15380 static PyObject *_wrap_ART_MENU_get(void) {
15381 PyObject *pyobj;
15382
15383 {
15384 #if wxUSE_UNICODE
15385 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15386 #else
15387 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15388 #endif
15389 }
15390 return pyobj;
15391 }
15392
15393
15394 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15395 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15396 return 1;
15397 }
15398
15399
15400 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15401 PyObject *pyobj;
15402
15403 {
15404 #if wxUSE_UNICODE
15405 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15406 #else
15407 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15408 #endif
15409 }
15410 return pyobj;
15411 }
15412
15413
15414 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15415 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15416 return 1;
15417 }
15418
15419
15420 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15421 PyObject *pyobj;
15422
15423 {
15424 #if wxUSE_UNICODE
15425 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15426 #else
15427 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15428 #endif
15429 }
15430 return pyobj;
15431 }
15432
15433
15434 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15435 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15436 return 1;
15437 }
15438
15439
15440 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15441 PyObject *pyobj;
15442
15443 {
15444 #if wxUSE_UNICODE
15445 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15446 #else
15447 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15448 #endif
15449 }
15450 return pyobj;
15451 }
15452
15453
15454 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15455 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15456 return 1;
15457 }
15458
15459
15460 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15461 PyObject *pyobj;
15462
15463 {
15464 #if wxUSE_UNICODE
15465 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15466 #else
15467 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15468 #endif
15469 }
15470 return pyobj;
15471 }
15472
15473
15474 static int _wrap_ART_BUTTON_set(PyObject *) {
15475 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15476 return 1;
15477 }
15478
15479
15480 static PyObject *_wrap_ART_BUTTON_get(void) {
15481 PyObject *pyobj;
15482
15483 {
15484 #if wxUSE_UNICODE
15485 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15486 #else
15487 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15488 #endif
15489 }
15490 return pyobj;
15491 }
15492
15493
15494 static int _wrap_ART_OTHER_set(PyObject *) {
15495 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15496 return 1;
15497 }
15498
15499
15500 static PyObject *_wrap_ART_OTHER_get(void) {
15501 PyObject *pyobj;
15502
15503 {
15504 #if wxUSE_UNICODE
15505 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15506 #else
15507 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15508 #endif
15509 }
15510 return pyobj;
15511 }
15512
15513
15514 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15515 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15516 return 1;
15517 }
15518
15519
15520 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15521 PyObject *pyobj;
15522
15523 {
15524 #if wxUSE_UNICODE
15525 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15526 #else
15527 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15528 #endif
15529 }
15530 return pyobj;
15531 }
15532
15533
15534 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15535 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15536 return 1;
15537 }
15538
15539
15540 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15541 PyObject *pyobj;
15542
15543 {
15544 #if wxUSE_UNICODE
15545 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15546 #else
15547 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15548 #endif
15549 }
15550 return pyobj;
15551 }
15552
15553
15554 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15555 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15556 return 1;
15557 }
15558
15559
15560 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15561 PyObject *pyobj;
15562
15563 {
15564 #if wxUSE_UNICODE
15565 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15566 #else
15567 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15568 #endif
15569 }
15570 return pyobj;
15571 }
15572
15573
15574 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15575 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15576 return 1;
15577 }
15578
15579
15580 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15581 PyObject *pyobj;
15582
15583 {
15584 #if wxUSE_UNICODE
15585 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15586 #else
15587 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15588 #endif
15589 }
15590 return pyobj;
15591 }
15592
15593
15594 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15595 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15596 return 1;
15597 }
15598
15599
15600 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15601 PyObject *pyobj;
15602
15603 {
15604 #if wxUSE_UNICODE
15605 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15606 #else
15607 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15608 #endif
15609 }
15610 return pyobj;
15611 }
15612
15613
15614 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15615 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15616 return 1;
15617 }
15618
15619
15620 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15621 PyObject *pyobj;
15622
15623 {
15624 #if wxUSE_UNICODE
15625 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15626 #else
15627 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15628 #endif
15629 }
15630 return pyobj;
15631 }
15632
15633
15634 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15635 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15636 return 1;
15637 }
15638
15639
15640 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15641 PyObject *pyobj;
15642
15643 {
15644 #if wxUSE_UNICODE
15645 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15646 #else
15647 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15648 #endif
15649 }
15650 return pyobj;
15651 }
15652
15653
15654 static int _wrap_ART_GO_BACK_set(PyObject *) {
15655 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15656 return 1;
15657 }
15658
15659
15660 static PyObject *_wrap_ART_GO_BACK_get(void) {
15661 PyObject *pyobj;
15662
15663 {
15664 #if wxUSE_UNICODE
15665 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15666 #else
15667 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15668 #endif
15669 }
15670 return pyobj;
15671 }
15672
15673
15674 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15675 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15676 return 1;
15677 }
15678
15679
15680 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15681 PyObject *pyobj;
15682
15683 {
15684 #if wxUSE_UNICODE
15685 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15686 #else
15687 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15688 #endif
15689 }
15690 return pyobj;
15691 }
15692
15693
15694 static int _wrap_ART_GO_UP_set(PyObject *) {
15695 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15696 return 1;
15697 }
15698
15699
15700 static PyObject *_wrap_ART_GO_UP_get(void) {
15701 PyObject *pyobj;
15702
15703 {
15704 #if wxUSE_UNICODE
15705 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15706 #else
15707 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15708 #endif
15709 }
15710 return pyobj;
15711 }
15712
15713
15714 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15715 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15716 return 1;
15717 }
15718
15719
15720 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15721 PyObject *pyobj;
15722
15723 {
15724 #if wxUSE_UNICODE
15725 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15726 #else
15727 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15728 #endif
15729 }
15730 return pyobj;
15731 }
15732
15733
15734 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15735 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15736 return 1;
15737 }
15738
15739
15740 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15741 PyObject *pyobj;
15742
15743 {
15744 #if wxUSE_UNICODE
15745 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15746 #else
15747 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15748 #endif
15749 }
15750 return pyobj;
15751 }
15752
15753
15754 static int _wrap_ART_GO_HOME_set(PyObject *) {
15755 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15756 return 1;
15757 }
15758
15759
15760 static PyObject *_wrap_ART_GO_HOME_get(void) {
15761 PyObject *pyobj;
15762
15763 {
15764 #if wxUSE_UNICODE
15765 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15766 #else
15767 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15768 #endif
15769 }
15770 return pyobj;
15771 }
15772
15773
15774 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15775 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15776 return 1;
15777 }
15778
15779
15780 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15781 PyObject *pyobj;
15782
15783 {
15784 #if wxUSE_UNICODE
15785 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15786 #else
15787 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15788 #endif
15789 }
15790 return pyobj;
15791 }
15792
15793
15794 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15795 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15796 return 1;
15797 }
15798
15799
15800 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15801 PyObject *pyobj;
15802
15803 {
15804 #if wxUSE_UNICODE
15805 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15806 #else
15807 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15808 #endif
15809 }
15810 return pyobj;
15811 }
15812
15813
15814 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15815 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15816 return 1;
15817 }
15818
15819
15820 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15821 PyObject *pyobj;
15822
15823 {
15824 #if wxUSE_UNICODE
15825 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15826 #else
15827 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15828 #endif
15829 }
15830 return pyobj;
15831 }
15832
15833
15834 static int _wrap_ART_PRINT_set(PyObject *) {
15835 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15836 return 1;
15837 }
15838
15839
15840 static PyObject *_wrap_ART_PRINT_get(void) {
15841 PyObject *pyobj;
15842
15843 {
15844 #if wxUSE_UNICODE
15845 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15846 #else
15847 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15848 #endif
15849 }
15850 return pyobj;
15851 }
15852
15853
15854 static int _wrap_ART_HELP_set(PyObject *) {
15855 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15856 return 1;
15857 }
15858
15859
15860 static PyObject *_wrap_ART_HELP_get(void) {
15861 PyObject *pyobj;
15862
15863 {
15864 #if wxUSE_UNICODE
15865 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15866 #else
15867 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15868 #endif
15869 }
15870 return pyobj;
15871 }
15872
15873
15874 static int _wrap_ART_TIP_set(PyObject *) {
15875 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15876 return 1;
15877 }
15878
15879
15880 static PyObject *_wrap_ART_TIP_get(void) {
15881 PyObject *pyobj;
15882
15883 {
15884 #if wxUSE_UNICODE
15885 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15886 #else
15887 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15888 #endif
15889 }
15890 return pyobj;
15891 }
15892
15893
15894 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15895 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15896 return 1;
15897 }
15898
15899
15900 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15901 PyObject *pyobj;
15902
15903 {
15904 #if wxUSE_UNICODE
15905 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15906 #else
15907 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15908 #endif
15909 }
15910 return pyobj;
15911 }
15912
15913
15914 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15915 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15916 return 1;
15917 }
15918
15919
15920 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15921 PyObject *pyobj;
15922
15923 {
15924 #if wxUSE_UNICODE
15925 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15926 #else
15927 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15928 #endif
15929 }
15930 return pyobj;
15931 }
15932
15933
15934 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15935 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15936 return 1;
15937 }
15938
15939
15940 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15941 PyObject *pyobj;
15942
15943 {
15944 #if wxUSE_UNICODE
15945 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15946 #else
15947 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15948 #endif
15949 }
15950 return pyobj;
15951 }
15952
15953
15954 static int _wrap_ART_HARDDISK_set(PyObject *) {
15955 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15956 return 1;
15957 }
15958
15959
15960 static PyObject *_wrap_ART_HARDDISK_get(void) {
15961 PyObject *pyobj;
15962
15963 {
15964 #if wxUSE_UNICODE
15965 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15966 #else
15967 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15968 #endif
15969 }
15970 return pyobj;
15971 }
15972
15973
15974 static int _wrap_ART_FLOPPY_set(PyObject *) {
15975 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15976 return 1;
15977 }
15978
15979
15980 static PyObject *_wrap_ART_FLOPPY_get(void) {
15981 PyObject *pyobj;
15982
15983 {
15984 #if wxUSE_UNICODE
15985 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15986 #else
15987 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15988 #endif
15989 }
15990 return pyobj;
15991 }
15992
15993
15994 static int _wrap_ART_CDROM_set(PyObject *) {
15995 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15996 return 1;
15997 }
15998
15999
16000 static PyObject *_wrap_ART_CDROM_get(void) {
16001 PyObject *pyobj;
16002
16003 {
16004 #if wxUSE_UNICODE
16005 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16006 #else
16007 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16008 #endif
16009 }
16010 return pyobj;
16011 }
16012
16013
16014 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16015 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16016 return 1;
16017 }
16018
16019
16020 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16021 PyObject *pyobj;
16022
16023 {
16024 #if wxUSE_UNICODE
16025 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16026 #else
16027 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16028 #endif
16029 }
16030 return pyobj;
16031 }
16032
16033
16034 static int _wrap_ART_FOLDER_set(PyObject *) {
16035 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16036 return 1;
16037 }
16038
16039
16040 static PyObject *_wrap_ART_FOLDER_get(void) {
16041 PyObject *pyobj;
16042
16043 {
16044 #if wxUSE_UNICODE
16045 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16046 #else
16047 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16048 #endif
16049 }
16050 return pyobj;
16051 }
16052
16053
16054 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16055 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16056 return 1;
16057 }
16058
16059
16060 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16061 PyObject *pyobj;
16062
16063 {
16064 #if wxUSE_UNICODE
16065 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16066 #else
16067 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16068 #endif
16069 }
16070 return pyobj;
16071 }
16072
16073
16074 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16075 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16076 return 1;
16077 }
16078
16079
16080 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16081 PyObject *pyobj;
16082
16083 {
16084 #if wxUSE_UNICODE
16085 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16086 #else
16087 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16088 #endif
16089 }
16090 return pyobj;
16091 }
16092
16093
16094 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16095 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16096 return 1;
16097 }
16098
16099
16100 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16101 PyObject *pyobj;
16102
16103 {
16104 #if wxUSE_UNICODE
16105 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16106 #else
16107 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16108 #endif
16109 }
16110 return pyobj;
16111 }
16112
16113
16114 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16115 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16116 return 1;
16117 }
16118
16119
16120 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16121 PyObject *pyobj;
16122
16123 {
16124 #if wxUSE_UNICODE
16125 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16126 #else
16127 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16128 #endif
16129 }
16130 return pyobj;
16131 }
16132
16133
16134 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16135 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16136 return 1;
16137 }
16138
16139
16140 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16141 PyObject *pyobj;
16142
16143 {
16144 #if wxUSE_UNICODE
16145 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16146 #else
16147 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16148 #endif
16149 }
16150 return pyobj;
16151 }
16152
16153
16154 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16155 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16156 return 1;
16157 }
16158
16159
16160 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16161 PyObject *pyobj;
16162
16163 {
16164 #if wxUSE_UNICODE
16165 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16166 #else
16167 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16168 #endif
16169 }
16170 return pyobj;
16171 }
16172
16173
16174 static int _wrap_ART_ERROR_set(PyObject *) {
16175 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16176 return 1;
16177 }
16178
16179
16180 static PyObject *_wrap_ART_ERROR_get(void) {
16181 PyObject *pyobj;
16182
16183 {
16184 #if wxUSE_UNICODE
16185 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16186 #else
16187 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16188 #endif
16189 }
16190 return pyobj;
16191 }
16192
16193
16194 static int _wrap_ART_QUESTION_set(PyObject *) {
16195 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16196 return 1;
16197 }
16198
16199
16200 static PyObject *_wrap_ART_QUESTION_get(void) {
16201 PyObject *pyobj;
16202
16203 {
16204 #if wxUSE_UNICODE
16205 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16206 #else
16207 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16208 #endif
16209 }
16210 return pyobj;
16211 }
16212
16213
16214 static int _wrap_ART_WARNING_set(PyObject *) {
16215 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16216 return 1;
16217 }
16218
16219
16220 static PyObject *_wrap_ART_WARNING_get(void) {
16221 PyObject *pyobj;
16222
16223 {
16224 #if wxUSE_UNICODE
16225 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16226 #else
16227 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16228 #endif
16229 }
16230 return pyobj;
16231 }
16232
16233
16234 static int _wrap_ART_INFORMATION_set(PyObject *) {
16235 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16236 return 1;
16237 }
16238
16239
16240 static PyObject *_wrap_ART_INFORMATION_get(void) {
16241 PyObject *pyobj;
16242
16243 {
16244 #if wxUSE_UNICODE
16245 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16246 #else
16247 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16248 #endif
16249 }
16250 return pyobj;
16251 }
16252
16253
16254 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16255 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16256 return 1;
16257 }
16258
16259
16260 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16261 PyObject *pyobj;
16262
16263 {
16264 #if wxUSE_UNICODE
16265 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16266 #else
16267 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16268 #endif
16269 }
16270 return pyobj;
16271 }
16272
16273
16274 static int _wrap_ART_COPY_set(PyObject *) {
16275 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16276 return 1;
16277 }
16278
16279
16280 static PyObject *_wrap_ART_COPY_get(void) {
16281 PyObject *pyobj;
16282
16283 {
16284 #if wxUSE_UNICODE
16285 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16286 #else
16287 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16288 #endif
16289 }
16290 return pyobj;
16291 }
16292
16293
16294 static int _wrap_ART_CUT_set(PyObject *) {
16295 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16296 return 1;
16297 }
16298
16299
16300 static PyObject *_wrap_ART_CUT_get(void) {
16301 PyObject *pyobj;
16302
16303 {
16304 #if wxUSE_UNICODE
16305 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16306 #else
16307 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16308 #endif
16309 }
16310 return pyobj;
16311 }
16312
16313
16314 static int _wrap_ART_PASTE_set(PyObject *) {
16315 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16316 return 1;
16317 }
16318
16319
16320 static PyObject *_wrap_ART_PASTE_get(void) {
16321 PyObject *pyobj;
16322
16323 {
16324 #if wxUSE_UNICODE
16325 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16326 #else
16327 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16328 #endif
16329 }
16330 return pyobj;
16331 }
16332
16333
16334 static int _wrap_ART_DELETE_set(PyObject *) {
16335 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16336 return 1;
16337 }
16338
16339
16340 static PyObject *_wrap_ART_DELETE_get(void) {
16341 PyObject *pyobj;
16342
16343 {
16344 #if wxUSE_UNICODE
16345 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16346 #else
16347 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16348 #endif
16349 }
16350 return pyobj;
16351 }
16352
16353
16354 static int _wrap_ART_UNDO_set(PyObject *) {
16355 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16356 return 1;
16357 }
16358
16359
16360 static PyObject *_wrap_ART_UNDO_get(void) {
16361 PyObject *pyobj;
16362
16363 {
16364 #if wxUSE_UNICODE
16365 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16366 #else
16367 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16368 #endif
16369 }
16370 return pyobj;
16371 }
16372
16373
16374 static int _wrap_ART_REDO_set(PyObject *) {
16375 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16376 return 1;
16377 }
16378
16379
16380 static PyObject *_wrap_ART_REDO_get(void) {
16381 PyObject *pyobj;
16382
16383 {
16384 #if wxUSE_UNICODE
16385 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16386 #else
16387 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16388 #endif
16389 }
16390 return pyobj;
16391 }
16392
16393
16394 static int _wrap_ART_QUIT_set(PyObject *) {
16395 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16396 return 1;
16397 }
16398
16399
16400 static PyObject *_wrap_ART_QUIT_get(void) {
16401 PyObject *pyobj;
16402
16403 {
16404 #if wxUSE_UNICODE
16405 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16406 #else
16407 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16408 #endif
16409 }
16410 return pyobj;
16411 }
16412
16413
16414 static int _wrap_ART_FIND_set(PyObject *) {
16415 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16416 return 1;
16417 }
16418
16419
16420 static PyObject *_wrap_ART_FIND_get(void) {
16421 PyObject *pyobj;
16422
16423 {
16424 #if wxUSE_UNICODE
16425 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16426 #else
16427 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16428 #endif
16429 }
16430 return pyobj;
16431 }
16432
16433
16434 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16435 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16436 return 1;
16437 }
16438
16439
16440 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16441 PyObject *pyobj;
16442
16443 {
16444 #if wxUSE_UNICODE
16445 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16446 #else
16447 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16448 #endif
16449 }
16450 return pyobj;
16451 }
16452
16453
16454 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16455 PyObject *resultobj;
16456 wxPyArtProvider *result;
16457 char *kwnames[] = {
16458 NULL
16459 };
16460
16461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16462 {
16463 if (!wxPyCheckForApp()) SWIG_fail;
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (wxPyArtProvider *)new wxPyArtProvider();
16466
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj;
16479 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16480 PyObject *arg2 = (PyObject *) 0 ;
16481 PyObject *arg3 = (PyObject *) 0 ;
16482 PyObject * obj0 = 0 ;
16483 PyObject * obj1 = 0 ;
16484 PyObject * obj2 = 0 ;
16485 char *kwnames[] = {
16486 (char *) "self",(char *) "self",(char *) "_class", NULL
16487 };
16488
16489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16491 if (SWIG_arg_fail(1)) SWIG_fail;
16492 arg2 = obj1;
16493 arg3 = obj2;
16494 {
16495 PyThreadState* __tstate = wxPyBeginAllowThreads();
16496 (arg1)->_setCallbackInfo(arg2,arg3);
16497
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 Py_INCREF(Py_None); resultobj = Py_None;
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16509 PyObject *resultobj;
16510 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16511 PyObject * obj0 = 0 ;
16512 char *kwnames[] = {
16513 (char *) "provider", NULL
16514 };
16515
16516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16518 if (SWIG_arg_fail(1)) SWIG_fail;
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxPyArtProvider::PushProvider(arg1);
16522
16523 wxPyEndAllowThreads(__tstate);
16524 if (PyErr_Occurred()) SWIG_fail;
16525 }
16526 Py_INCREF(Py_None); resultobj = Py_None;
16527 return resultobj;
16528 fail:
16529 return NULL;
16530 }
16531
16532
16533 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16534 PyObject *resultobj;
16535 bool result;
16536 char *kwnames[] = {
16537 NULL
16538 };
16539
16540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16541 {
16542 PyThreadState* __tstate = wxPyBeginAllowThreads();
16543 result = (bool)wxPyArtProvider::PopProvider();
16544
16545 wxPyEndAllowThreads(__tstate);
16546 if (PyErr_Occurred()) SWIG_fail;
16547 }
16548 {
16549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16550 }
16551 return resultobj;
16552 fail:
16553 return NULL;
16554 }
16555
16556
16557 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16558 PyObject *resultobj;
16559 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16560 bool result;
16561 PyObject * obj0 = 0 ;
16562 char *kwnames[] = {
16563 (char *) "provider", NULL
16564 };
16565
16566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16568 if (SWIG_arg_fail(1)) SWIG_fail;
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16572
16573 wxPyEndAllowThreads(__tstate);
16574 if (PyErr_Occurred()) SWIG_fail;
16575 }
16576 {
16577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16578 }
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj;
16587 wxString *arg1 = 0 ;
16588 wxString const &arg2_defvalue = wxPyART_OTHER ;
16589 wxString *arg2 = (wxString *) &arg2_defvalue ;
16590 wxSize const &arg3_defvalue = wxDefaultSize ;
16591 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16592 wxBitmap result;
16593 bool temp1 = false ;
16594 bool temp2 = false ;
16595 wxSize temp3 ;
16596 PyObject * obj0 = 0 ;
16597 PyObject * obj1 = 0 ;
16598 PyObject * obj2 = 0 ;
16599 char *kwnames[] = {
16600 (char *) "id",(char *) "client",(char *) "size", NULL
16601 };
16602
16603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16604 {
16605 arg1 = wxString_in_helper(obj0);
16606 if (arg1 == NULL) SWIG_fail;
16607 temp1 = true;
16608 }
16609 if (obj1) {
16610 {
16611 arg2 = wxString_in_helper(obj1);
16612 if (arg2 == NULL) SWIG_fail;
16613 temp2 = true;
16614 }
16615 }
16616 if (obj2) {
16617 {
16618 arg3 = &temp3;
16619 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16620 }
16621 }
16622 {
16623 if (!wxPyCheckForApp()) SWIG_fail;
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16626
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 {
16631 wxBitmap * resultptr;
16632 resultptr = new wxBitmap((wxBitmap &)(result));
16633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16634 }
16635 {
16636 if (temp1)
16637 delete arg1;
16638 }
16639 {
16640 if (temp2)
16641 delete arg2;
16642 }
16643 return resultobj;
16644 fail:
16645 {
16646 if (temp1)
16647 delete arg1;
16648 }
16649 {
16650 if (temp2)
16651 delete arg2;
16652 }
16653 return NULL;
16654 }
16655
16656
16657 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16658 PyObject *resultobj;
16659 wxString *arg1 = 0 ;
16660 wxString const &arg2_defvalue = wxPyART_OTHER ;
16661 wxString *arg2 = (wxString *) &arg2_defvalue ;
16662 wxSize const &arg3_defvalue = wxDefaultSize ;
16663 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16664 wxIcon result;
16665 bool temp1 = false ;
16666 bool temp2 = false ;
16667 wxSize temp3 ;
16668 PyObject * obj0 = 0 ;
16669 PyObject * obj1 = 0 ;
16670 PyObject * obj2 = 0 ;
16671 char *kwnames[] = {
16672 (char *) "id",(char *) "client",(char *) "size", NULL
16673 };
16674
16675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16676 {
16677 arg1 = wxString_in_helper(obj0);
16678 if (arg1 == NULL) SWIG_fail;
16679 temp1 = true;
16680 }
16681 if (obj1) {
16682 {
16683 arg2 = wxString_in_helper(obj1);
16684 if (arg2 == NULL) SWIG_fail;
16685 temp2 = true;
16686 }
16687 }
16688 if (obj2) {
16689 {
16690 arg3 = &temp3;
16691 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16692 }
16693 }
16694 {
16695 if (!wxPyCheckForApp()) SWIG_fail;
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16698
16699 wxPyEndAllowThreads(__tstate);
16700 if (PyErr_Occurred()) SWIG_fail;
16701 }
16702 {
16703 wxIcon * resultptr;
16704 resultptr = new wxIcon((wxIcon &)(result));
16705 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16706 }
16707 {
16708 if (temp1)
16709 delete arg1;
16710 }
16711 {
16712 if (temp2)
16713 delete arg2;
16714 }
16715 return resultobj;
16716 fail:
16717 {
16718 if (temp1)
16719 delete arg1;
16720 }
16721 {
16722 if (temp2)
16723 delete arg2;
16724 }
16725 return NULL;
16726 }
16727
16728
16729 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16730 PyObject *resultobj;
16731 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16732 PyObject * obj0 = 0 ;
16733 char *kwnames[] = {
16734 (char *) "self", NULL
16735 };
16736
16737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16739 if (SWIG_arg_fail(1)) SWIG_fail;
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 wxPyArtProvider_Destroy(arg1);
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 Py_INCREF(Py_None); resultobj = Py_None;
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16755 PyObject *obj;
16756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16757 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16758 Py_INCREF(obj);
16759 return Py_BuildValue((char *)"");
16760 }
16761 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16762 PyObject *resultobj;
16763 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16764 PyObject * obj0 = 0 ;
16765 char *kwnames[] = {
16766 (char *) "self", NULL
16767 };
16768
16769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16771 if (SWIG_arg_fail(1)) SWIG_fail;
16772 {
16773 PyThreadState* __tstate = wxPyBeginAllowThreads();
16774 delete arg1;
16775
16776 wxPyEndAllowThreads(__tstate);
16777 if (PyErr_Occurred()) SWIG_fail;
16778 }
16779 Py_INCREF(Py_None); resultobj = Py_None;
16780 return resultobj;
16781 fail:
16782 return NULL;
16783 }
16784
16785
16786 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16787 PyObject *resultobj;
16788 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16789 wxConfigBase *result;
16790 PyObject * obj0 = 0 ;
16791 char *kwnames[] = {
16792 (char *) "config", NULL
16793 };
16794
16795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16797 if (SWIG_arg_fail(1)) SWIG_fail;
16798 {
16799 PyThreadState* __tstate = wxPyBeginAllowThreads();
16800 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16801
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj;
16814 bool arg1 = (bool) true ;
16815 wxConfigBase *result;
16816 PyObject * obj0 = 0 ;
16817 char *kwnames[] = {
16818 (char *) "createOnDemand", NULL
16819 };
16820
16821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16822 if (obj0) {
16823 {
16824 arg1 = (bool)(SWIG_As_bool(obj0));
16825 if (SWIG_arg_fail(1)) SWIG_fail;
16826 }
16827 }
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16831
16832 wxPyEndAllowThreads(__tstate);
16833 if (PyErr_Occurred()) SWIG_fail;
16834 }
16835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16836 return resultobj;
16837 fail:
16838 return NULL;
16839 }
16840
16841
16842 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16843 PyObject *resultobj;
16844 wxConfigBase *result;
16845 char *kwnames[] = {
16846 NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16850 {
16851 PyThreadState* __tstate = wxPyBeginAllowThreads();
16852 result = (wxConfigBase *)wxConfigBase::Create();
16853
16854 wxPyEndAllowThreads(__tstate);
16855 if (PyErr_Occurred()) SWIG_fail;
16856 }
16857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16858 return resultobj;
16859 fail:
16860 return NULL;
16861 }
16862
16863
16864 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16865 PyObject *resultobj;
16866 char *kwnames[] = {
16867 NULL
16868 };
16869
16870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 wxConfigBase::DontCreateOnDemand();
16874
16875 wxPyEndAllowThreads(__tstate);
16876 if (PyErr_Occurred()) SWIG_fail;
16877 }
16878 Py_INCREF(Py_None); resultobj = Py_None;
16879 return resultobj;
16880 fail:
16881 return NULL;
16882 }
16883
16884
16885 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16886 PyObject *resultobj;
16887 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16888 wxString *arg2 = 0 ;
16889 bool temp2 = false ;
16890 PyObject * obj0 = 0 ;
16891 PyObject * obj1 = 0 ;
16892 char *kwnames[] = {
16893 (char *) "self",(char *) "path", NULL
16894 };
16895
16896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16898 if (SWIG_arg_fail(1)) SWIG_fail;
16899 {
16900 arg2 = wxString_in_helper(obj1);
16901 if (arg2 == NULL) SWIG_fail;
16902 temp2 = true;
16903 }
16904 {
16905 PyThreadState* __tstate = wxPyBeginAllowThreads();
16906 (arg1)->SetPath((wxString const &)*arg2);
16907
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 Py_INCREF(Py_None); resultobj = Py_None;
16912 {
16913 if (temp2)
16914 delete arg2;
16915 }
16916 return resultobj;
16917 fail:
16918 {
16919 if (temp2)
16920 delete arg2;
16921 }
16922 return NULL;
16923 }
16924
16925
16926 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16927 PyObject *resultobj;
16928 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16929 wxString *result;
16930 PyObject * obj0 = 0 ;
16931 char *kwnames[] = {
16932 (char *) "self", NULL
16933 };
16934
16935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16937 if (SWIG_arg_fail(1)) SWIG_fail;
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 {
16941 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16942 result = (wxString *) &_result_ref;
16943 }
16944
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 {
16949 #if wxUSE_UNICODE
16950 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16951 #else
16952 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16953 #endif
16954 }
16955 return resultobj;
16956 fail:
16957 return NULL;
16958 }
16959
16960
16961 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16962 PyObject *resultobj;
16963 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16964 PyObject *result;
16965 PyObject * obj0 = 0 ;
16966 char *kwnames[] = {
16967 (char *) "self", NULL
16968 };
16969
16970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16972 if (SWIG_arg_fail(1)) SWIG_fail;
16973 {
16974 PyThreadState* __tstate = wxPyBeginAllowThreads();
16975 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16976
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 resultobj = result;
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16990 long arg2 ;
16991 PyObject *result;
16992 PyObject * obj0 = 0 ;
16993 PyObject * obj1 = 0 ;
16994 char *kwnames[] = {
16995 (char *) "self",(char *) "index", NULL
16996 };
16997
16998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
16999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17000 if (SWIG_arg_fail(1)) SWIG_fail;
17001 {
17002 arg2 = (long)(SWIG_As_long(obj1));
17003 if (SWIG_arg_fail(2)) SWIG_fail;
17004 }
17005 {
17006 PyThreadState* __tstate = wxPyBeginAllowThreads();
17007 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17008
17009 wxPyEndAllowThreads(__tstate);
17010 if (PyErr_Occurred()) SWIG_fail;
17011 }
17012 resultobj = result;
17013 return resultobj;
17014 fail:
17015 return NULL;
17016 }
17017
17018
17019 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17020 PyObject *resultobj;
17021 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17022 PyObject *result;
17023 PyObject * obj0 = 0 ;
17024 char *kwnames[] = {
17025 (char *) "self", NULL
17026 };
17027
17028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17030 if (SWIG_arg_fail(1)) SWIG_fail;
17031 {
17032 PyThreadState* __tstate = wxPyBeginAllowThreads();
17033 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17034
17035 wxPyEndAllowThreads(__tstate);
17036 if (PyErr_Occurred()) SWIG_fail;
17037 }
17038 resultobj = result;
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj;
17047 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17048 long arg2 ;
17049 PyObject *result;
17050 PyObject * obj0 = 0 ;
17051 PyObject * obj1 = 0 ;
17052 char *kwnames[] = {
17053 (char *) "self",(char *) "index", NULL
17054 };
17055
17056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17058 if (SWIG_arg_fail(1)) SWIG_fail;
17059 {
17060 arg2 = (long)(SWIG_As_long(obj1));
17061 if (SWIG_arg_fail(2)) SWIG_fail;
17062 }
17063 {
17064 PyThreadState* __tstate = wxPyBeginAllowThreads();
17065 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17066
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 resultobj = result;
17071 return resultobj;
17072 fail:
17073 return NULL;
17074 }
17075
17076
17077 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17078 PyObject *resultobj;
17079 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17080 bool arg2 = (bool) false ;
17081 size_t result;
17082 PyObject * obj0 = 0 ;
17083 PyObject * obj1 = 0 ;
17084 char *kwnames[] = {
17085 (char *) "self",(char *) "recursive", NULL
17086 };
17087
17088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17090 if (SWIG_arg_fail(1)) SWIG_fail;
17091 if (obj1) {
17092 {
17093 arg2 = (bool)(SWIG_As_bool(obj1));
17094 if (SWIG_arg_fail(2)) SWIG_fail;
17095 }
17096 }
17097 {
17098 PyThreadState* __tstate = wxPyBeginAllowThreads();
17099 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17100
17101 wxPyEndAllowThreads(__tstate);
17102 if (PyErr_Occurred()) SWIG_fail;
17103 }
17104 {
17105 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17106 }
17107 return resultobj;
17108 fail:
17109 return NULL;
17110 }
17111
17112
17113 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17114 PyObject *resultobj;
17115 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17116 bool arg2 = (bool) false ;
17117 size_t result;
17118 PyObject * obj0 = 0 ;
17119 PyObject * obj1 = 0 ;
17120 char *kwnames[] = {
17121 (char *) "self",(char *) "recursive", NULL
17122 };
17123
17124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17126 if (SWIG_arg_fail(1)) SWIG_fail;
17127 if (obj1) {
17128 {
17129 arg2 = (bool)(SWIG_As_bool(obj1));
17130 if (SWIG_arg_fail(2)) SWIG_fail;
17131 }
17132 }
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17136
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 {
17141 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17142 }
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj;
17151 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17152 wxString *arg2 = 0 ;
17153 bool result;
17154 bool temp2 = false ;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 char *kwnames[] = {
17158 (char *) "self",(char *) "name", NULL
17159 };
17160
17161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17163 if (SWIG_arg_fail(1)) SWIG_fail;
17164 {
17165 arg2 = wxString_in_helper(obj1);
17166 if (arg2 == NULL) SWIG_fail;
17167 temp2 = true;
17168 }
17169 {
17170 PyThreadState* __tstate = wxPyBeginAllowThreads();
17171 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17172
17173 wxPyEndAllowThreads(__tstate);
17174 if (PyErr_Occurred()) SWIG_fail;
17175 }
17176 {
17177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17178 }
17179 {
17180 if (temp2)
17181 delete arg2;
17182 }
17183 return resultobj;
17184 fail:
17185 {
17186 if (temp2)
17187 delete arg2;
17188 }
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj;
17195 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17196 wxString *arg2 = 0 ;
17197 bool result;
17198 bool temp2 = false ;
17199 PyObject * obj0 = 0 ;
17200 PyObject * obj1 = 0 ;
17201 char *kwnames[] = {
17202 (char *) "self",(char *) "name", NULL
17203 };
17204
17205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",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 {
17209 arg2 = wxString_in_helper(obj1);
17210 if (arg2 == NULL) SWIG_fail;
17211 temp2 = true;
17212 }
17213 {
17214 PyThreadState* __tstate = wxPyBeginAllowThreads();
17215 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17216
17217 wxPyEndAllowThreads(__tstate);
17218 if (PyErr_Occurred()) SWIG_fail;
17219 }
17220 {
17221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17222 }
17223 {
17224 if (temp2)
17225 delete arg2;
17226 }
17227 return resultobj;
17228 fail:
17229 {
17230 if (temp2)
17231 delete arg2;
17232 }
17233 return NULL;
17234 }
17235
17236
17237 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17238 PyObject *resultobj;
17239 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17240 wxString *arg2 = 0 ;
17241 bool result;
17242 bool temp2 = false ;
17243 PyObject * obj0 = 0 ;
17244 PyObject * obj1 = 0 ;
17245 char *kwnames[] = {
17246 (char *) "self",(char *) "name", NULL
17247 };
17248
17249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17251 if (SWIG_arg_fail(1)) SWIG_fail;
17252 {
17253 arg2 = wxString_in_helper(obj1);
17254 if (arg2 == NULL) SWIG_fail;
17255 temp2 = true;
17256 }
17257 {
17258 PyThreadState* __tstate = wxPyBeginAllowThreads();
17259 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17260
17261 wxPyEndAllowThreads(__tstate);
17262 if (PyErr_Occurred()) SWIG_fail;
17263 }
17264 {
17265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17266 }
17267 {
17268 if (temp2)
17269 delete arg2;
17270 }
17271 return resultobj;
17272 fail:
17273 {
17274 if (temp2)
17275 delete arg2;
17276 }
17277 return NULL;
17278 }
17279
17280
17281 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17282 PyObject *resultobj;
17283 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17284 wxString *arg2 = 0 ;
17285 wxConfigBase::EntryType result;
17286 bool temp2 = false ;
17287 PyObject * obj0 = 0 ;
17288 PyObject * obj1 = 0 ;
17289 char *kwnames[] = {
17290 (char *) "self",(char *) "name", NULL
17291 };
17292
17293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17295 if (SWIG_arg_fail(1)) SWIG_fail;
17296 {
17297 arg2 = wxString_in_helper(obj1);
17298 if (arg2 == NULL) SWIG_fail;
17299 temp2 = true;
17300 }
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17304
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 resultobj = SWIG_From_int((result));
17309 {
17310 if (temp2)
17311 delete arg2;
17312 }
17313 return resultobj;
17314 fail:
17315 {
17316 if (temp2)
17317 delete arg2;
17318 }
17319 return NULL;
17320 }
17321
17322
17323 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17324 PyObject *resultobj;
17325 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17326 wxString *arg2 = 0 ;
17327 wxString const &arg3_defvalue = wxPyEmptyString ;
17328 wxString *arg3 = (wxString *) &arg3_defvalue ;
17329 wxString result;
17330 bool temp2 = false ;
17331 bool temp3 = false ;
17332 PyObject * obj0 = 0 ;
17333 PyObject * obj1 = 0 ;
17334 PyObject * obj2 = 0 ;
17335 char *kwnames[] = {
17336 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17337 };
17338
17339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17341 if (SWIG_arg_fail(1)) SWIG_fail;
17342 {
17343 arg2 = wxString_in_helper(obj1);
17344 if (arg2 == NULL) SWIG_fail;
17345 temp2 = true;
17346 }
17347 if (obj2) {
17348 {
17349 arg3 = wxString_in_helper(obj2);
17350 if (arg3 == NULL) SWIG_fail;
17351 temp3 = true;
17352 }
17353 }
17354 {
17355 PyThreadState* __tstate = wxPyBeginAllowThreads();
17356 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17357
17358 wxPyEndAllowThreads(__tstate);
17359 if (PyErr_Occurred()) SWIG_fail;
17360 }
17361 {
17362 #if wxUSE_UNICODE
17363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17364 #else
17365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17366 #endif
17367 }
17368 {
17369 if (temp2)
17370 delete arg2;
17371 }
17372 {
17373 if (temp3)
17374 delete arg3;
17375 }
17376 return resultobj;
17377 fail:
17378 {
17379 if (temp2)
17380 delete arg2;
17381 }
17382 {
17383 if (temp3)
17384 delete arg3;
17385 }
17386 return NULL;
17387 }
17388
17389
17390 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj;
17392 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17393 wxString *arg2 = 0 ;
17394 long arg3 = (long) 0 ;
17395 long result;
17396 bool temp2 = false ;
17397 PyObject * obj0 = 0 ;
17398 PyObject * obj1 = 0 ;
17399 PyObject * obj2 = 0 ;
17400 char *kwnames[] = {
17401 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17402 };
17403
17404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17406 if (SWIG_arg_fail(1)) SWIG_fail;
17407 {
17408 arg2 = wxString_in_helper(obj1);
17409 if (arg2 == NULL) SWIG_fail;
17410 temp2 = true;
17411 }
17412 if (obj2) {
17413 {
17414 arg3 = (long)(SWIG_As_long(obj2));
17415 if (SWIG_arg_fail(3)) SWIG_fail;
17416 }
17417 }
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17421
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 {
17426 resultobj = SWIG_From_long((long)(result));
17427 }
17428 {
17429 if (temp2)
17430 delete arg2;
17431 }
17432 return resultobj;
17433 fail:
17434 {
17435 if (temp2)
17436 delete arg2;
17437 }
17438 return NULL;
17439 }
17440
17441
17442 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj;
17444 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17445 wxString *arg2 = 0 ;
17446 double arg3 = (double) 0.0 ;
17447 double result;
17448 bool temp2 = 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_ReadFloat",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 = (double)(SWIG_As_double(obj2));
17467 if (SWIG_arg_fail(3)) SWIG_fail;
17468 }
17469 }
17470 {
17471 PyThreadState* __tstate = wxPyBeginAllowThreads();
17472 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17473
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = SWIG_From_double((double)(result));
17479 }
17480 {
17481 if (temp2)
17482 delete arg2;
17483 }
17484 return resultobj;
17485 fail:
17486 {
17487 if (temp2)
17488 delete arg2;
17489 }
17490 return NULL;
17491 }
17492
17493
17494 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17495 PyObject *resultobj;
17496 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17497 wxString *arg2 = 0 ;
17498 bool arg3 = (bool) false ;
17499 bool result;
17500 bool temp2 = false ;
17501 PyObject * obj0 = 0 ;
17502 PyObject * obj1 = 0 ;
17503 PyObject * obj2 = 0 ;
17504 char *kwnames[] = {
17505 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17506 };
17507
17508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17510 if (SWIG_arg_fail(1)) SWIG_fail;
17511 {
17512 arg2 = wxString_in_helper(obj1);
17513 if (arg2 == NULL) SWIG_fail;
17514 temp2 = true;
17515 }
17516 if (obj2) {
17517 {
17518 arg3 = (bool)(SWIG_As_bool(obj2));
17519 if (SWIG_arg_fail(3)) SWIG_fail;
17520 }
17521 }
17522 {
17523 PyThreadState* __tstate = wxPyBeginAllowThreads();
17524 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17525
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 {
17530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17531 }
17532 {
17533 if (temp2)
17534 delete arg2;
17535 }
17536 return resultobj;
17537 fail:
17538 {
17539 if (temp2)
17540 delete arg2;
17541 }
17542 return NULL;
17543 }
17544
17545
17546 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17547 PyObject *resultobj;
17548 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17549 wxString *arg2 = 0 ;
17550 wxString *arg3 = 0 ;
17551 bool result;
17552 bool temp2 = false ;
17553 bool temp3 = false ;
17554 PyObject * obj0 = 0 ;
17555 PyObject * obj1 = 0 ;
17556 PyObject * obj2 = 0 ;
17557 char *kwnames[] = {
17558 (char *) "self",(char *) "key",(char *) "value", NULL
17559 };
17560
17561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17563 if (SWIG_arg_fail(1)) SWIG_fail;
17564 {
17565 arg2 = wxString_in_helper(obj1);
17566 if (arg2 == NULL) SWIG_fail;
17567 temp2 = true;
17568 }
17569 {
17570 arg3 = wxString_in_helper(obj2);
17571 if (arg3 == NULL) SWIG_fail;
17572 temp3 = true;
17573 }
17574 {
17575 PyThreadState* __tstate = wxPyBeginAllowThreads();
17576 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17577
17578 wxPyEndAllowThreads(__tstate);
17579 if (PyErr_Occurred()) SWIG_fail;
17580 }
17581 {
17582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17583 }
17584 {
17585 if (temp2)
17586 delete arg2;
17587 }
17588 {
17589 if (temp3)
17590 delete arg3;
17591 }
17592 return resultobj;
17593 fail:
17594 {
17595 if (temp2)
17596 delete arg2;
17597 }
17598 {
17599 if (temp3)
17600 delete arg3;
17601 }
17602 return NULL;
17603 }
17604
17605
17606 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17607 PyObject *resultobj;
17608 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17609 wxString *arg2 = 0 ;
17610 long arg3 ;
17611 bool result;
17612 bool temp2 = false ;
17613 PyObject * obj0 = 0 ;
17614 PyObject * obj1 = 0 ;
17615 PyObject * obj2 = 0 ;
17616 char *kwnames[] = {
17617 (char *) "self",(char *) "key",(char *) "value", NULL
17618 };
17619
17620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17622 if (SWIG_arg_fail(1)) SWIG_fail;
17623 {
17624 arg2 = wxString_in_helper(obj1);
17625 if (arg2 == NULL) SWIG_fail;
17626 temp2 = true;
17627 }
17628 {
17629 arg3 = (long)(SWIG_As_long(obj2));
17630 if (SWIG_arg_fail(3)) SWIG_fail;
17631 }
17632 {
17633 PyThreadState* __tstate = wxPyBeginAllowThreads();
17634 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17635
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 {
17640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17641 }
17642 {
17643 if (temp2)
17644 delete arg2;
17645 }
17646 return resultobj;
17647 fail:
17648 {
17649 if (temp2)
17650 delete arg2;
17651 }
17652 return NULL;
17653 }
17654
17655
17656 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17657 PyObject *resultobj;
17658 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17659 wxString *arg2 = 0 ;
17660 double arg3 ;
17661 bool result;
17662 bool temp2 = false ;
17663 PyObject * obj0 = 0 ;
17664 PyObject * obj1 = 0 ;
17665 PyObject * obj2 = 0 ;
17666 char *kwnames[] = {
17667 (char *) "self",(char *) "key",(char *) "value", NULL
17668 };
17669
17670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17672 if (SWIG_arg_fail(1)) SWIG_fail;
17673 {
17674 arg2 = wxString_in_helper(obj1);
17675 if (arg2 == NULL) SWIG_fail;
17676 temp2 = true;
17677 }
17678 {
17679 arg3 = (double)(SWIG_As_double(obj2));
17680 if (SWIG_arg_fail(3)) SWIG_fail;
17681 }
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17685
17686 wxPyEndAllowThreads(__tstate);
17687 if (PyErr_Occurred()) SWIG_fail;
17688 }
17689 {
17690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17691 }
17692 {
17693 if (temp2)
17694 delete arg2;
17695 }
17696 return resultobj;
17697 fail:
17698 {
17699 if (temp2)
17700 delete arg2;
17701 }
17702 return NULL;
17703 }
17704
17705
17706 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17707 PyObject *resultobj;
17708 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17709 wxString *arg2 = 0 ;
17710 bool arg3 ;
17711 bool result;
17712 bool temp2 = false ;
17713 PyObject * obj0 = 0 ;
17714 PyObject * obj1 = 0 ;
17715 PyObject * obj2 = 0 ;
17716 char *kwnames[] = {
17717 (char *) "self",(char *) "key",(char *) "value", NULL
17718 };
17719
17720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17722 if (SWIG_arg_fail(1)) SWIG_fail;
17723 {
17724 arg2 = wxString_in_helper(obj1);
17725 if (arg2 == NULL) SWIG_fail;
17726 temp2 = true;
17727 }
17728 {
17729 arg3 = (bool)(SWIG_As_bool(obj2));
17730 if (SWIG_arg_fail(3)) SWIG_fail;
17731 }
17732 {
17733 PyThreadState* __tstate = wxPyBeginAllowThreads();
17734 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17735
17736 wxPyEndAllowThreads(__tstate);
17737 if (PyErr_Occurred()) SWIG_fail;
17738 }
17739 {
17740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17741 }
17742 {
17743 if (temp2)
17744 delete arg2;
17745 }
17746 return resultobj;
17747 fail:
17748 {
17749 if (temp2)
17750 delete arg2;
17751 }
17752 return NULL;
17753 }
17754
17755
17756 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj;
17758 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17759 bool arg2 = (bool) false ;
17760 bool result;
17761 PyObject * obj0 = 0 ;
17762 PyObject * obj1 = 0 ;
17763 char *kwnames[] = {
17764 (char *) "self",(char *) "currentOnly", NULL
17765 };
17766
17767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17769 if (SWIG_arg_fail(1)) SWIG_fail;
17770 if (obj1) {
17771 {
17772 arg2 = (bool)(SWIG_As_bool(obj1));
17773 if (SWIG_arg_fail(2)) SWIG_fail;
17774 }
17775 }
17776 {
17777 PyThreadState* __tstate = wxPyBeginAllowThreads();
17778 result = (bool)(arg1)->Flush(arg2);
17779
17780 wxPyEndAllowThreads(__tstate);
17781 if (PyErr_Occurred()) SWIG_fail;
17782 }
17783 {
17784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17785 }
17786 return resultobj;
17787 fail:
17788 return NULL;
17789 }
17790
17791
17792 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17793 PyObject *resultobj;
17794 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17795 wxString *arg2 = 0 ;
17796 wxString *arg3 = 0 ;
17797 bool result;
17798 bool temp2 = false ;
17799 bool temp3 = false ;
17800 PyObject * obj0 = 0 ;
17801 PyObject * obj1 = 0 ;
17802 PyObject * obj2 = 0 ;
17803 char *kwnames[] = {
17804 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17805 };
17806
17807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17809 if (SWIG_arg_fail(1)) SWIG_fail;
17810 {
17811 arg2 = wxString_in_helper(obj1);
17812 if (arg2 == NULL) SWIG_fail;
17813 temp2 = true;
17814 }
17815 {
17816 arg3 = wxString_in_helper(obj2);
17817 if (arg3 == NULL) SWIG_fail;
17818 temp3 = true;
17819 }
17820 {
17821 PyThreadState* __tstate = wxPyBeginAllowThreads();
17822 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17823
17824 wxPyEndAllowThreads(__tstate);
17825 if (PyErr_Occurred()) SWIG_fail;
17826 }
17827 {
17828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17829 }
17830 {
17831 if (temp2)
17832 delete arg2;
17833 }
17834 {
17835 if (temp3)
17836 delete arg3;
17837 }
17838 return resultobj;
17839 fail:
17840 {
17841 if (temp2)
17842 delete arg2;
17843 }
17844 {
17845 if (temp3)
17846 delete arg3;
17847 }
17848 return NULL;
17849 }
17850
17851
17852 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17853 PyObject *resultobj;
17854 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17855 wxString *arg2 = 0 ;
17856 wxString *arg3 = 0 ;
17857 bool result;
17858 bool temp2 = false ;
17859 bool temp3 = false ;
17860 PyObject * obj0 = 0 ;
17861 PyObject * obj1 = 0 ;
17862 PyObject * obj2 = 0 ;
17863 char *kwnames[] = {
17864 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17865 };
17866
17867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17869 if (SWIG_arg_fail(1)) SWIG_fail;
17870 {
17871 arg2 = wxString_in_helper(obj1);
17872 if (arg2 == NULL) SWIG_fail;
17873 temp2 = true;
17874 }
17875 {
17876 arg3 = wxString_in_helper(obj2);
17877 if (arg3 == NULL) SWIG_fail;
17878 temp3 = true;
17879 }
17880 {
17881 PyThreadState* __tstate = wxPyBeginAllowThreads();
17882 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17883
17884 wxPyEndAllowThreads(__tstate);
17885 if (PyErr_Occurred()) SWIG_fail;
17886 }
17887 {
17888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17889 }
17890 {
17891 if (temp2)
17892 delete arg2;
17893 }
17894 {
17895 if (temp3)
17896 delete arg3;
17897 }
17898 return resultobj;
17899 fail:
17900 {
17901 if (temp2)
17902 delete arg2;
17903 }
17904 {
17905 if (temp3)
17906 delete arg3;
17907 }
17908 return NULL;
17909 }
17910
17911
17912 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17913 PyObject *resultobj;
17914 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17915 wxString *arg2 = 0 ;
17916 bool arg3 = (bool) true ;
17917 bool result;
17918 bool temp2 = false ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 PyObject * obj2 = 0 ;
17922 char *kwnames[] = {
17923 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17924 };
17925
17926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17928 if (SWIG_arg_fail(1)) SWIG_fail;
17929 {
17930 arg2 = wxString_in_helper(obj1);
17931 if (arg2 == NULL) SWIG_fail;
17932 temp2 = true;
17933 }
17934 if (obj2) {
17935 {
17936 arg3 = (bool)(SWIG_As_bool(obj2));
17937 if (SWIG_arg_fail(3)) SWIG_fail;
17938 }
17939 }
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17943
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 {
17948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17949 }
17950 {
17951 if (temp2)
17952 delete arg2;
17953 }
17954 return resultobj;
17955 fail:
17956 {
17957 if (temp2)
17958 delete arg2;
17959 }
17960 return NULL;
17961 }
17962
17963
17964 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17965 PyObject *resultobj;
17966 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17967 wxString *arg2 = 0 ;
17968 bool result;
17969 bool temp2 = false ;
17970 PyObject * obj0 = 0 ;
17971 PyObject * obj1 = 0 ;
17972 char *kwnames[] = {
17973 (char *) "self",(char *) "key", NULL
17974 };
17975
17976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17978 if (SWIG_arg_fail(1)) SWIG_fail;
17979 {
17980 arg2 = wxString_in_helper(obj1);
17981 if (arg2 == NULL) SWIG_fail;
17982 temp2 = true;
17983 }
17984 {
17985 PyThreadState* __tstate = wxPyBeginAllowThreads();
17986 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17987
17988 wxPyEndAllowThreads(__tstate);
17989 if (PyErr_Occurred()) SWIG_fail;
17990 }
17991 {
17992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17993 }
17994 {
17995 if (temp2)
17996 delete arg2;
17997 }
17998 return resultobj;
17999 fail:
18000 {
18001 if (temp2)
18002 delete arg2;
18003 }
18004 return NULL;
18005 }
18006
18007
18008 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18009 PyObject *resultobj;
18010 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18011 bool result;
18012 PyObject * obj0 = 0 ;
18013 char *kwnames[] = {
18014 (char *) "self", NULL
18015 };
18016
18017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18019 if (SWIG_arg_fail(1)) SWIG_fail;
18020 {
18021 PyThreadState* __tstate = wxPyBeginAllowThreads();
18022 result = (bool)(arg1)->DeleteAll();
18023
18024 wxPyEndAllowThreads(__tstate);
18025 if (PyErr_Occurred()) SWIG_fail;
18026 }
18027 {
18028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18029 }
18030 return resultobj;
18031 fail:
18032 return NULL;
18033 }
18034
18035
18036 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18037 PyObject *resultobj;
18038 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18039 bool arg2 = (bool) true ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 char *kwnames[] = {
18043 (char *) "self",(char *) "doIt", NULL
18044 };
18045
18046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18048 if (SWIG_arg_fail(1)) SWIG_fail;
18049 if (obj1) {
18050 {
18051 arg2 = (bool)(SWIG_As_bool(obj1));
18052 if (SWIG_arg_fail(2)) SWIG_fail;
18053 }
18054 }
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 (arg1)->SetExpandEnvVars(arg2);
18058
18059 wxPyEndAllowThreads(__tstate);
18060 if (PyErr_Occurred()) SWIG_fail;
18061 }
18062 Py_INCREF(Py_None); resultobj = Py_None;
18063 return resultobj;
18064 fail:
18065 return NULL;
18066 }
18067
18068
18069 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj;
18071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18072 bool result;
18073 PyObject * obj0 = 0 ;
18074 char *kwnames[] = {
18075 (char *) "self", NULL
18076 };
18077
18078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18080 if (SWIG_arg_fail(1)) SWIG_fail;
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18084
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 {
18089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18090 }
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18098 PyObject *resultobj;
18099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18100 bool arg2 = (bool) true ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 char *kwnames[] = {
18104 (char *) "self",(char *) "doIt", NULL
18105 };
18106
18107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18109 if (SWIG_arg_fail(1)) SWIG_fail;
18110 if (obj1) {
18111 {
18112 arg2 = (bool)(SWIG_As_bool(obj1));
18113 if (SWIG_arg_fail(2)) SWIG_fail;
18114 }
18115 }
18116 {
18117 PyThreadState* __tstate = wxPyBeginAllowThreads();
18118 (arg1)->SetRecordDefaults(arg2);
18119
18120 wxPyEndAllowThreads(__tstate);
18121 if (PyErr_Occurred()) SWIG_fail;
18122 }
18123 Py_INCREF(Py_None); resultobj = Py_None;
18124 return resultobj;
18125 fail:
18126 return NULL;
18127 }
18128
18129
18130 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18131 PyObject *resultobj;
18132 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18133 bool result;
18134 PyObject * obj0 = 0 ;
18135 char *kwnames[] = {
18136 (char *) "self", NULL
18137 };
18138
18139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18141 if (SWIG_arg_fail(1)) SWIG_fail;
18142 {
18143 PyThreadState* __tstate = wxPyBeginAllowThreads();
18144 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18145
18146 wxPyEndAllowThreads(__tstate);
18147 if (PyErr_Occurred()) SWIG_fail;
18148 }
18149 {
18150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18161 wxString *arg2 = 0 ;
18162 wxString result;
18163 bool temp2 = false ;
18164 PyObject * obj0 = 0 ;
18165 PyObject * obj1 = 0 ;
18166 char *kwnames[] = {
18167 (char *) "self",(char *) "str", NULL
18168 };
18169
18170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18172 if (SWIG_arg_fail(1)) SWIG_fail;
18173 {
18174 arg2 = wxString_in_helper(obj1);
18175 if (arg2 == NULL) SWIG_fail;
18176 temp2 = true;
18177 }
18178 {
18179 PyThreadState* __tstate = wxPyBeginAllowThreads();
18180 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18181
18182 wxPyEndAllowThreads(__tstate);
18183 if (PyErr_Occurred()) SWIG_fail;
18184 }
18185 {
18186 #if wxUSE_UNICODE
18187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18188 #else
18189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18190 #endif
18191 }
18192 {
18193 if (temp2)
18194 delete arg2;
18195 }
18196 return resultobj;
18197 fail:
18198 {
18199 if (temp2)
18200 delete arg2;
18201 }
18202 return NULL;
18203 }
18204
18205
18206 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18207 PyObject *resultobj;
18208 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18209 wxString result;
18210 PyObject * obj0 = 0 ;
18211 char *kwnames[] = {
18212 (char *) "self", NULL
18213 };
18214
18215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18217 if (SWIG_arg_fail(1)) SWIG_fail;
18218 {
18219 PyThreadState* __tstate = wxPyBeginAllowThreads();
18220 result = ((wxConfigBase const *)arg1)->GetAppName();
18221
18222 wxPyEndAllowThreads(__tstate);
18223 if (PyErr_Occurred()) SWIG_fail;
18224 }
18225 {
18226 #if wxUSE_UNICODE
18227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18228 #else
18229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18230 #endif
18231 }
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj;
18240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18241 wxString result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = ((wxConfigBase const *)arg1)->GetVendorName();
18253
18254 wxPyEndAllowThreads(__tstate);
18255 if (PyErr_Occurred()) SWIG_fail;
18256 }
18257 {
18258 #if wxUSE_UNICODE
18259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18260 #else
18261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18262 #endif
18263 }
18264 return resultobj;
18265 fail:
18266 return NULL;
18267 }
18268
18269
18270 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18271 PyObject *resultobj;
18272 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18273 wxString *arg2 = 0 ;
18274 bool temp2 = false ;
18275 PyObject * obj0 = 0 ;
18276 PyObject * obj1 = 0 ;
18277 char *kwnames[] = {
18278 (char *) "self",(char *) "appName", NULL
18279 };
18280
18281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18283 if (SWIG_arg_fail(1)) SWIG_fail;
18284 {
18285 arg2 = wxString_in_helper(obj1);
18286 if (arg2 == NULL) SWIG_fail;
18287 temp2 = true;
18288 }
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 (arg1)->SetAppName((wxString const &)*arg2);
18292
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 Py_INCREF(Py_None); resultobj = Py_None;
18297 {
18298 if (temp2)
18299 delete arg2;
18300 }
18301 return resultobj;
18302 fail:
18303 {
18304 if (temp2)
18305 delete arg2;
18306 }
18307 return NULL;
18308 }
18309
18310
18311 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj;
18313 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18314 wxString *arg2 = 0 ;
18315 bool temp2 = false ;
18316 PyObject * obj0 = 0 ;
18317 PyObject * obj1 = 0 ;
18318 char *kwnames[] = {
18319 (char *) "self",(char *) "vendorName", NULL
18320 };
18321
18322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18324 if (SWIG_arg_fail(1)) SWIG_fail;
18325 {
18326 arg2 = wxString_in_helper(obj1);
18327 if (arg2 == NULL) SWIG_fail;
18328 temp2 = true;
18329 }
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 (arg1)->SetVendorName((wxString const &)*arg2);
18333
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 Py_INCREF(Py_None); resultobj = Py_None;
18338 {
18339 if (temp2)
18340 delete arg2;
18341 }
18342 return resultobj;
18343 fail:
18344 {
18345 if (temp2)
18346 delete arg2;
18347 }
18348 return NULL;
18349 }
18350
18351
18352 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18353 PyObject *resultobj;
18354 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18355 long arg2 ;
18356 PyObject * obj0 = 0 ;
18357 PyObject * obj1 = 0 ;
18358 char *kwnames[] = {
18359 (char *) "self",(char *) "style", NULL
18360 };
18361
18362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18364 if (SWIG_arg_fail(1)) SWIG_fail;
18365 {
18366 arg2 = (long)(SWIG_As_long(obj1));
18367 if (SWIG_arg_fail(2)) SWIG_fail;
18368 }
18369 {
18370 PyThreadState* __tstate = wxPyBeginAllowThreads();
18371 (arg1)->SetStyle(arg2);
18372
18373 wxPyEndAllowThreads(__tstate);
18374 if (PyErr_Occurred()) SWIG_fail;
18375 }
18376 Py_INCREF(Py_None); resultobj = Py_None;
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj;
18385 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18386 long result;
18387 PyObject * obj0 = 0 ;
18388 char *kwnames[] = {
18389 (char *) "self", NULL
18390 };
18391
18392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18394 if (SWIG_arg_fail(1)) SWIG_fail;
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18398
18399 wxPyEndAllowThreads(__tstate);
18400 if (PyErr_Occurred()) SWIG_fail;
18401 }
18402 {
18403 resultobj = SWIG_From_long((long)(result));
18404 }
18405 return resultobj;
18406 fail:
18407 return NULL;
18408 }
18409
18410
18411 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18412 PyObject *obj;
18413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18414 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18415 Py_INCREF(obj);
18416 return Py_BuildValue((char *)"");
18417 }
18418 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18419 PyObject *resultobj;
18420 wxString const &arg1_defvalue = wxPyEmptyString ;
18421 wxString *arg1 = (wxString *) &arg1_defvalue ;
18422 wxString const &arg2_defvalue = wxPyEmptyString ;
18423 wxString *arg2 = (wxString *) &arg2_defvalue ;
18424 wxString const &arg3_defvalue = wxPyEmptyString ;
18425 wxString *arg3 = (wxString *) &arg3_defvalue ;
18426 wxString const &arg4_defvalue = wxPyEmptyString ;
18427 wxString *arg4 = (wxString *) &arg4_defvalue ;
18428 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18429 wxConfig *result;
18430 bool temp1 = false ;
18431 bool temp2 = false ;
18432 bool temp3 = false ;
18433 bool temp4 = false ;
18434 PyObject * obj0 = 0 ;
18435 PyObject * obj1 = 0 ;
18436 PyObject * obj2 = 0 ;
18437 PyObject * obj3 = 0 ;
18438 PyObject * obj4 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18444 if (obj0) {
18445 {
18446 arg1 = wxString_in_helper(obj0);
18447 if (arg1 == NULL) SWIG_fail;
18448 temp1 = true;
18449 }
18450 }
18451 if (obj1) {
18452 {
18453 arg2 = wxString_in_helper(obj1);
18454 if (arg2 == NULL) SWIG_fail;
18455 temp2 = true;
18456 }
18457 }
18458 if (obj2) {
18459 {
18460 arg3 = wxString_in_helper(obj2);
18461 if (arg3 == NULL) SWIG_fail;
18462 temp3 = true;
18463 }
18464 }
18465 if (obj3) {
18466 {
18467 arg4 = wxString_in_helper(obj3);
18468 if (arg4 == NULL) SWIG_fail;
18469 temp4 = true;
18470 }
18471 }
18472 if (obj4) {
18473 {
18474 arg5 = (long)(SWIG_As_long(obj4));
18475 if (SWIG_arg_fail(5)) SWIG_fail;
18476 }
18477 }
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18481
18482 wxPyEndAllowThreads(__tstate);
18483 if (PyErr_Occurred()) SWIG_fail;
18484 }
18485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18486 {
18487 if (temp1)
18488 delete arg1;
18489 }
18490 {
18491 if (temp2)
18492 delete arg2;
18493 }
18494 {
18495 if (temp3)
18496 delete arg3;
18497 }
18498 {
18499 if (temp4)
18500 delete arg4;
18501 }
18502 return resultobj;
18503 fail:
18504 {
18505 if (temp1)
18506 delete arg1;
18507 }
18508 {
18509 if (temp2)
18510 delete arg2;
18511 }
18512 {
18513 if (temp3)
18514 delete arg3;
18515 }
18516 {
18517 if (temp4)
18518 delete arg4;
18519 }
18520 return NULL;
18521 }
18522
18523
18524 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18525 PyObject *resultobj;
18526 wxConfig *arg1 = (wxConfig *) 0 ;
18527 PyObject * obj0 = 0 ;
18528 char *kwnames[] = {
18529 (char *) "self", NULL
18530 };
18531
18532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18534 if (SWIG_arg_fail(1)) SWIG_fail;
18535 {
18536 PyThreadState* __tstate = wxPyBeginAllowThreads();
18537 delete arg1;
18538
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 Py_INCREF(Py_None); resultobj = Py_None;
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18550 PyObject *obj;
18551 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18552 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18553 Py_INCREF(obj);
18554 return Py_BuildValue((char *)"");
18555 }
18556 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxString const &arg1_defvalue = wxPyEmptyString ;
18559 wxString *arg1 = (wxString *) &arg1_defvalue ;
18560 wxString const &arg2_defvalue = wxPyEmptyString ;
18561 wxString *arg2 = (wxString *) &arg2_defvalue ;
18562 wxString const &arg3_defvalue = wxPyEmptyString ;
18563 wxString *arg3 = (wxString *) &arg3_defvalue ;
18564 wxString const &arg4_defvalue = wxPyEmptyString ;
18565 wxString *arg4 = (wxString *) &arg4_defvalue ;
18566 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18567 wxFileConfig *result;
18568 bool temp1 = false ;
18569 bool temp2 = false ;
18570 bool temp3 = false ;
18571 bool temp4 = false ;
18572 PyObject * obj0 = 0 ;
18573 PyObject * obj1 = 0 ;
18574 PyObject * obj2 = 0 ;
18575 PyObject * obj3 = 0 ;
18576 PyObject * obj4 = 0 ;
18577 char *kwnames[] = {
18578 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18579 };
18580
18581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18582 if (obj0) {
18583 {
18584 arg1 = wxString_in_helper(obj0);
18585 if (arg1 == NULL) SWIG_fail;
18586 temp1 = true;
18587 }
18588 }
18589 if (obj1) {
18590 {
18591 arg2 = wxString_in_helper(obj1);
18592 if (arg2 == NULL) SWIG_fail;
18593 temp2 = true;
18594 }
18595 }
18596 if (obj2) {
18597 {
18598 arg3 = wxString_in_helper(obj2);
18599 if (arg3 == NULL) SWIG_fail;
18600 temp3 = true;
18601 }
18602 }
18603 if (obj3) {
18604 {
18605 arg4 = wxString_in_helper(obj3);
18606 if (arg4 == NULL) SWIG_fail;
18607 temp4 = true;
18608 }
18609 }
18610 if (obj4) {
18611 {
18612 arg5 = (long)(SWIG_As_long(obj4));
18613 if (SWIG_arg_fail(5)) SWIG_fail;
18614 }
18615 }
18616 {
18617 PyThreadState* __tstate = wxPyBeginAllowThreads();
18618 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18619
18620 wxPyEndAllowThreads(__tstate);
18621 if (PyErr_Occurred()) SWIG_fail;
18622 }
18623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18624 {
18625 if (temp1)
18626 delete arg1;
18627 }
18628 {
18629 if (temp2)
18630 delete arg2;
18631 }
18632 {
18633 if (temp3)
18634 delete arg3;
18635 }
18636 {
18637 if (temp4)
18638 delete arg4;
18639 }
18640 return resultobj;
18641 fail:
18642 {
18643 if (temp1)
18644 delete arg1;
18645 }
18646 {
18647 if (temp2)
18648 delete arg2;
18649 }
18650 {
18651 if (temp3)
18652 delete arg3;
18653 }
18654 {
18655 if (temp4)
18656 delete arg4;
18657 }
18658 return NULL;
18659 }
18660
18661
18662 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18663 PyObject *resultobj;
18664 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18665 PyObject * obj0 = 0 ;
18666 char *kwnames[] = {
18667 (char *) "self", NULL
18668 };
18669
18670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18672 if (SWIG_arg_fail(1)) SWIG_fail;
18673 {
18674 PyThreadState* __tstate = wxPyBeginAllowThreads();
18675 delete arg1;
18676
18677 wxPyEndAllowThreads(__tstate);
18678 if (PyErr_Occurred()) SWIG_fail;
18679 }
18680 Py_INCREF(Py_None); resultobj = Py_None;
18681 return resultobj;
18682 fail:
18683 return NULL;
18684 }
18685
18686
18687 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18688 PyObject *obj;
18689 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18690 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18691 Py_INCREF(obj);
18692 return Py_BuildValue((char *)"");
18693 }
18694 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18695 PyObject *resultobj;
18696 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18697 wxString *arg2 = 0 ;
18698 wxConfigPathChanger *result;
18699 bool temp2 = false ;
18700 PyObject * obj0 = 0 ;
18701 PyObject * obj1 = 0 ;
18702 char *kwnames[] = {
18703 (char *) "config",(char *) "entry", NULL
18704 };
18705
18706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18708 if (SWIG_arg_fail(1)) SWIG_fail;
18709 {
18710 arg2 = wxString_in_helper(obj1);
18711 if (arg2 == NULL) SWIG_fail;
18712 temp2 = true;
18713 }
18714 {
18715 PyThreadState* __tstate = wxPyBeginAllowThreads();
18716 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18717
18718 wxPyEndAllowThreads(__tstate);
18719 if (PyErr_Occurred()) SWIG_fail;
18720 }
18721 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18722 {
18723 if (temp2)
18724 delete arg2;
18725 }
18726 return resultobj;
18727 fail:
18728 {
18729 if (temp2)
18730 delete arg2;
18731 }
18732 return NULL;
18733 }
18734
18735
18736 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj;
18738 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18739 PyObject * obj0 = 0 ;
18740 char *kwnames[] = {
18741 (char *) "self", NULL
18742 };
18743
18744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18746 if (SWIG_arg_fail(1)) SWIG_fail;
18747 {
18748 PyThreadState* __tstate = wxPyBeginAllowThreads();
18749 delete arg1;
18750
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 Py_INCREF(Py_None); resultobj = Py_None;
18755 return resultobj;
18756 fail:
18757 return NULL;
18758 }
18759
18760
18761 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18762 PyObject *resultobj;
18763 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18764 wxString *result;
18765 PyObject * obj0 = 0 ;
18766 char *kwnames[] = {
18767 (char *) "self", NULL
18768 };
18769
18770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18772 if (SWIG_arg_fail(1)) SWIG_fail;
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 {
18776 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18777 result = (wxString *) &_result_ref;
18778 }
18779
18780 wxPyEndAllowThreads(__tstate);
18781 if (PyErr_Occurred()) SWIG_fail;
18782 }
18783 {
18784 #if wxUSE_UNICODE
18785 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18786 #else
18787 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18788 #endif
18789 }
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18797 PyObject *obj;
18798 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18799 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18800 Py_INCREF(obj);
18801 return Py_BuildValue((char *)"");
18802 }
18803 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18804 PyObject *resultobj;
18805 wxString *arg1 = 0 ;
18806 wxString result;
18807 bool temp1 = false ;
18808 PyObject * obj0 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "sz", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18814 {
18815 arg1 = wxString_in_helper(obj0);
18816 if (arg1 == NULL) SWIG_fail;
18817 temp1 = true;
18818 }
18819 {
18820 PyThreadState* __tstate = wxPyBeginAllowThreads();
18821 result = wxExpandEnvVars((wxString const &)*arg1);
18822
18823 wxPyEndAllowThreads(__tstate);
18824 if (PyErr_Occurred()) SWIG_fail;
18825 }
18826 {
18827 #if wxUSE_UNICODE
18828 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18829 #else
18830 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18831 #endif
18832 }
18833 {
18834 if (temp1)
18835 delete arg1;
18836 }
18837 return resultobj;
18838 fail:
18839 {
18840 if (temp1)
18841 delete arg1;
18842 }
18843 return NULL;
18844 }
18845
18846
18847 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18848 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18849 return 1;
18850 }
18851
18852
18853 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18854 PyObject *pyobj;
18855
18856 {
18857 #if wxUSE_UNICODE
18858 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18859 #else
18860 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18861 #endif
18862 }
18863 return pyobj;
18864 }
18865
18866
18867 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18868 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18869 return 1;
18870 }
18871
18872
18873 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18874 PyObject *pyobj;
18875
18876 {
18877 #if wxUSE_UNICODE
18878 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18879 #else
18880 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18881 #endif
18882 }
18883 return pyobj;
18884 }
18885
18886
18887 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj;
18889 wxDateTime::Country arg1 ;
18890 PyObject * obj0 = 0 ;
18891 char *kwnames[] = {
18892 (char *) "country", NULL
18893 };
18894
18895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18896 {
18897 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18898 if (SWIG_arg_fail(1)) SWIG_fail;
18899 }
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18903
18904 wxPyEndAllowThreads(__tstate);
18905 if (PyErr_Occurred()) SWIG_fail;
18906 }
18907 Py_INCREF(Py_None); resultobj = Py_None;
18908 return resultobj;
18909 fail:
18910 return NULL;
18911 }
18912
18913
18914 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18915 PyObject *resultobj;
18916 wxDateTime::Country result;
18917 char *kwnames[] = {
18918 NULL
18919 };
18920
18921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18922 {
18923 PyThreadState* __tstate = wxPyBeginAllowThreads();
18924 result = (wxDateTime::Country)wxDateTime::GetCountry();
18925
18926 wxPyEndAllowThreads(__tstate);
18927 if (PyErr_Occurred()) SWIG_fail;
18928 }
18929 resultobj = SWIG_From_int((result));
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj;
18938 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18939 bool result;
18940 PyObject * obj0 = 0 ;
18941 char *kwnames[] = {
18942 (char *) "country", NULL
18943 };
18944
18945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18946 if (obj0) {
18947 {
18948 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 }
18951 }
18952 {
18953 PyThreadState* __tstate = wxPyBeginAllowThreads();
18954 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18955
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 {
18960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18961 }
18962 return resultobj;
18963 fail:
18964 return NULL;
18965 }
18966
18967
18968 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18969 PyObject *resultobj;
18970 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18971 int result;
18972 PyObject * obj0 = 0 ;
18973 char *kwnames[] = {
18974 (char *) "cal", NULL
18975 };
18976
18977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18978 if (obj0) {
18979 {
18980 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18981 if (SWIG_arg_fail(1)) SWIG_fail;
18982 }
18983 }
18984 {
18985 PyThreadState* __tstate = wxPyBeginAllowThreads();
18986 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18987
18988 wxPyEndAllowThreads(__tstate);
18989 if (PyErr_Occurred()) SWIG_fail;
18990 }
18991 {
18992 resultobj = SWIG_From_int((int)(result));
18993 }
18994 return resultobj;
18995 fail:
18996 return NULL;
18997 }
18998
18999
19000 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19001 PyObject *resultobj;
19002 int arg1 ;
19003 int result;
19004 PyObject * obj0 = 0 ;
19005 char *kwnames[] = {
19006 (char *) "year", NULL
19007 };
19008
19009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19010 {
19011 arg1 = (int)(SWIG_As_int(obj0));
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 }
19014 {
19015 PyThreadState* __tstate = wxPyBeginAllowThreads();
19016 result = (int)wxDateTime::ConvertYearToBC(arg1);
19017
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 {
19022 resultobj = SWIG_From_int((int)(result));
19023 }
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj;
19032 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19033 wxDateTime::Month result;
19034 PyObject * obj0 = 0 ;
19035 char *kwnames[] = {
19036 (char *) "cal", NULL
19037 };
19038
19039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19040 if (obj0) {
19041 {
19042 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19043 if (SWIG_arg_fail(1)) SWIG_fail;
19044 }
19045 }
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19049
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 resultobj = SWIG_From_int((result));
19054 return resultobj;
19055 fail:
19056 return NULL;
19057 }
19058
19059
19060 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19061 PyObject *resultobj;
19062 int arg1 = (int) wxDateTime::Inv_Year ;
19063 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19064 bool result;
19065 PyObject * obj0 = 0 ;
19066 PyObject * obj1 = 0 ;
19067 char *kwnames[] = {
19068 (char *) "year",(char *) "cal", NULL
19069 };
19070
19071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19072 if (obj0) {
19073 {
19074 arg1 = (int)(SWIG_As_int(obj0));
19075 if (SWIG_arg_fail(1)) SWIG_fail;
19076 }
19077 }
19078 if (obj1) {
19079 {
19080 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19081 if (SWIG_arg_fail(2)) SWIG_fail;
19082 }
19083 }
19084 {
19085 PyThreadState* __tstate = wxPyBeginAllowThreads();
19086 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19087
19088 wxPyEndAllowThreads(__tstate);
19089 if (PyErr_Occurred()) SWIG_fail;
19090 }
19091 {
19092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19093 }
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj;
19102 int arg1 = (int) wxDateTime::Inv_Year ;
19103 int result;
19104 PyObject * obj0 = 0 ;
19105 char *kwnames[] = {
19106 (char *) "year", NULL
19107 };
19108
19109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19110 if (obj0) {
19111 {
19112 arg1 = (int)(SWIG_As_int(obj0));
19113 if (SWIG_arg_fail(1)) SWIG_fail;
19114 }
19115 }
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 result = (int)wxDateTime::GetCentury(arg1);
19119
19120 wxPyEndAllowThreads(__tstate);
19121 if (PyErr_Occurred()) SWIG_fail;
19122 }
19123 {
19124 resultobj = SWIG_From_int((int)(result));
19125 }
19126 return resultobj;
19127 fail:
19128 return NULL;
19129 }
19130
19131
19132 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj;
19134 int arg1 ;
19135 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19136 int result;
19137 PyObject * obj0 = 0 ;
19138 PyObject * obj1 = 0 ;
19139 char *kwnames[] = {
19140 (char *) "year",(char *) "cal", NULL
19141 };
19142
19143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19144 {
19145 arg1 = (int)(SWIG_As_int(obj0));
19146 if (SWIG_arg_fail(1)) SWIG_fail;
19147 }
19148 if (obj1) {
19149 {
19150 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19151 if (SWIG_arg_fail(2)) SWIG_fail;
19152 }
19153 }
19154 {
19155 PyThreadState* __tstate = wxPyBeginAllowThreads();
19156 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19157
19158 wxPyEndAllowThreads(__tstate);
19159 if (PyErr_Occurred()) SWIG_fail;
19160 }
19161 {
19162 resultobj = SWIG_From_int((int)(result));
19163 }
19164 return resultobj;
19165 fail:
19166 return NULL;
19167 }
19168
19169
19170 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19171 PyObject *resultobj;
19172 wxDateTime::Month arg1 ;
19173 int arg2 = (int) wxDateTime::Inv_Year ;
19174 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19175 int result;
19176 PyObject * obj0 = 0 ;
19177 PyObject * obj1 = 0 ;
19178 PyObject * obj2 = 0 ;
19179 char *kwnames[] = {
19180 (char *) "month",(char *) "year",(char *) "cal", NULL
19181 };
19182
19183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19184 {
19185 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19186 if (SWIG_arg_fail(1)) SWIG_fail;
19187 }
19188 if (obj1) {
19189 {
19190 arg2 = (int)(SWIG_As_int(obj1));
19191 if (SWIG_arg_fail(2)) SWIG_fail;
19192 }
19193 }
19194 if (obj2) {
19195 {
19196 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19197 if (SWIG_arg_fail(3)) SWIG_fail;
19198 }
19199 }
19200 {
19201 PyThreadState* __tstate = wxPyBeginAllowThreads();
19202 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19203
19204 wxPyEndAllowThreads(__tstate);
19205 if (PyErr_Occurred()) SWIG_fail;
19206 }
19207 {
19208 resultobj = SWIG_From_int((int)(result));
19209 }
19210 return resultobj;
19211 fail:
19212 return NULL;
19213 }
19214
19215
19216 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj;
19218 wxDateTime::Month arg1 ;
19219 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19220 wxString result;
19221 PyObject * obj0 = 0 ;
19222 PyObject * obj1 = 0 ;
19223 char *kwnames[] = {
19224 (char *) "month",(char *) "flags", NULL
19225 };
19226
19227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19228 {
19229 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19230 if (SWIG_arg_fail(1)) SWIG_fail;
19231 }
19232 if (obj1) {
19233 {
19234 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19235 if (SWIG_arg_fail(2)) SWIG_fail;
19236 }
19237 }
19238 {
19239 PyThreadState* __tstate = wxPyBeginAllowThreads();
19240 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19241
19242 wxPyEndAllowThreads(__tstate);
19243 if (PyErr_Occurred()) SWIG_fail;
19244 }
19245 {
19246 #if wxUSE_UNICODE
19247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19248 #else
19249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19250 #endif
19251 }
19252 return resultobj;
19253 fail:
19254 return NULL;
19255 }
19256
19257
19258 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19259 PyObject *resultobj;
19260 wxDateTime::WeekDay arg1 ;
19261 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19262 wxString result;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char *kwnames[] = {
19266 (char *) "weekday",(char *) "flags", NULL
19267 };
19268
19269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19270 {
19271 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19272 if (SWIG_arg_fail(1)) SWIG_fail;
19273 }
19274 if (obj1) {
19275 {
19276 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19277 if (SWIG_arg_fail(2)) SWIG_fail;
19278 }
19279 }
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19283
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 #if wxUSE_UNICODE
19289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19290 #else
19291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19292 #endif
19293 }
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19301 PyObject *resultobj;
19302 wxString *arg1 = (wxString *) 0 ;
19303 wxString *arg2 = (wxString *) 0 ;
19304 bool temp1 = false ;
19305 bool temp2 = false ;
19306 PyObject * obj0 = 0 ;
19307 PyObject * obj1 = 0 ;
19308 char *kwnames[] = {
19309 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19310 };
19311
19312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19313 {
19314 arg1 = wxString_in_helper(obj0);
19315 if (arg1 == NULL) SWIG_fail;
19316 temp1 = true;
19317 }
19318 {
19319 arg2 = wxString_in_helper(obj1);
19320 if (arg2 == NULL) SWIG_fail;
19321 temp2 = true;
19322 }
19323 {
19324 PyThreadState* __tstate = wxPyBeginAllowThreads();
19325 wxDateTime::GetAmPmStrings(arg1,arg2);
19326
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 Py_INCREF(Py_None); resultobj = Py_None;
19331 {
19332 if (temp1)
19333 delete arg1;
19334 }
19335 {
19336 if (temp2)
19337 delete arg2;
19338 }
19339 return resultobj;
19340 fail:
19341 {
19342 if (temp1)
19343 delete arg1;
19344 }
19345 {
19346 if (temp2)
19347 delete arg2;
19348 }
19349 return NULL;
19350 }
19351
19352
19353 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19354 PyObject *resultobj;
19355 int arg1 = (int) wxDateTime::Inv_Year ;
19356 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19357 bool result;
19358 PyObject * obj0 = 0 ;
19359 PyObject * obj1 = 0 ;
19360 char *kwnames[] = {
19361 (char *) "year",(char *) "country", NULL
19362 };
19363
19364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19365 if (obj0) {
19366 {
19367 arg1 = (int)(SWIG_As_int(obj0));
19368 if (SWIG_arg_fail(1)) SWIG_fail;
19369 }
19370 }
19371 if (obj1) {
19372 {
19373 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19374 if (SWIG_arg_fail(2)) SWIG_fail;
19375 }
19376 }
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19380
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 {
19385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19386 }
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19394 PyObject *resultobj;
19395 int arg1 = (int) wxDateTime::Inv_Year ;
19396 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19397 wxDateTime result;
19398 PyObject * obj0 = 0 ;
19399 PyObject * obj1 = 0 ;
19400 char *kwnames[] = {
19401 (char *) "year",(char *) "country", NULL
19402 };
19403
19404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19405 if (obj0) {
19406 {
19407 arg1 = (int)(SWIG_As_int(obj0));
19408 if (SWIG_arg_fail(1)) SWIG_fail;
19409 }
19410 }
19411 if (obj1) {
19412 {
19413 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19414 if (SWIG_arg_fail(2)) SWIG_fail;
19415 }
19416 }
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19420
19421 wxPyEndAllowThreads(__tstate);
19422 if (PyErr_Occurred()) SWIG_fail;
19423 }
19424 {
19425 wxDateTime * resultptr;
19426 resultptr = new wxDateTime((wxDateTime &)(result));
19427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19428 }
19429 return resultobj;
19430 fail:
19431 return NULL;
19432 }
19433
19434
19435 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19436 PyObject *resultobj;
19437 int arg1 = (int) wxDateTime::Inv_Year ;
19438 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19439 wxDateTime result;
19440 PyObject * obj0 = 0 ;
19441 PyObject * obj1 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "year",(char *) "country", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19447 if (obj0) {
19448 {
19449 arg1 = (int)(SWIG_As_int(obj0));
19450 if (SWIG_arg_fail(1)) SWIG_fail;
19451 }
19452 }
19453 if (obj1) {
19454 {
19455 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19456 if (SWIG_arg_fail(2)) SWIG_fail;
19457 }
19458 }
19459 {
19460 PyThreadState* __tstate = wxPyBeginAllowThreads();
19461 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19462
19463 wxPyEndAllowThreads(__tstate);
19464 if (PyErr_Occurred()) SWIG_fail;
19465 }
19466 {
19467 wxDateTime * resultptr;
19468 resultptr = new wxDateTime((wxDateTime &)(result));
19469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19470 }
19471 return resultobj;
19472 fail:
19473 return NULL;
19474 }
19475
19476
19477 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19478 PyObject *resultobj;
19479 wxDateTime result;
19480 char *kwnames[] = {
19481 NULL
19482 };
19483
19484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = wxDateTime::Now();
19488
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 {
19493 wxDateTime * resultptr;
19494 resultptr = new wxDateTime((wxDateTime &)(result));
19495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19496 }
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj;
19505 wxDateTime result;
19506 char *kwnames[] = {
19507 NULL
19508 };
19509
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19511 {
19512 PyThreadState* __tstate = wxPyBeginAllowThreads();
19513 result = wxDateTime::UNow();
19514
19515 wxPyEndAllowThreads(__tstate);
19516 if (PyErr_Occurred()) SWIG_fail;
19517 }
19518 {
19519 wxDateTime * resultptr;
19520 resultptr = new wxDateTime((wxDateTime &)(result));
19521 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj;
19531 wxDateTime result;
19532 char *kwnames[] = {
19533 NULL
19534 };
19535
19536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19537 {
19538 PyThreadState* __tstate = wxPyBeginAllowThreads();
19539 result = wxDateTime::Today();
19540
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 {
19545 wxDateTime * resultptr;
19546 resultptr = new wxDateTime((wxDateTime &)(result));
19547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19548 }
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj;
19557 wxDateTime *result;
19558 char *kwnames[] = {
19559 NULL
19560 };
19561
19562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19563 {
19564 PyThreadState* __tstate = wxPyBeginAllowThreads();
19565 result = (wxDateTime *)new wxDateTime();
19566
19567 wxPyEndAllowThreads(__tstate);
19568 if (PyErr_Occurred()) SWIG_fail;
19569 }
19570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19571 return resultobj;
19572 fail:
19573 return NULL;
19574 }
19575
19576
19577 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19578 PyObject *resultobj;
19579 time_t arg1 ;
19580 wxDateTime *result;
19581 PyObject * obj0 = 0 ;
19582 char *kwnames[] = {
19583 (char *) "timet", NULL
19584 };
19585
19586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19587 {
19588 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19589 if (SWIG_arg_fail(1)) SWIG_fail;
19590 }
19591 {
19592 PyThreadState* __tstate = wxPyBeginAllowThreads();
19593 result = (wxDateTime *)new wxDateTime(arg1);
19594
19595 wxPyEndAllowThreads(__tstate);
19596 if (PyErr_Occurred()) SWIG_fail;
19597 }
19598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19599 return resultobj;
19600 fail:
19601 return NULL;
19602 }
19603
19604
19605 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19606 PyObject *resultobj;
19607 double arg1 ;
19608 wxDateTime *result;
19609 PyObject * obj0 = 0 ;
19610 char *kwnames[] = {
19611 (char *) "jdn", NULL
19612 };
19613
19614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19615 {
19616 arg1 = (double)(SWIG_As_double(obj0));
19617 if (SWIG_arg_fail(1)) SWIG_fail;
19618 }
19619 {
19620 PyThreadState* __tstate = wxPyBeginAllowThreads();
19621 result = (wxDateTime *)new wxDateTime(arg1);
19622
19623 wxPyEndAllowThreads(__tstate);
19624 if (PyErr_Occurred()) SWIG_fail;
19625 }
19626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 int arg1 ;
19636 int arg2 = (int) 0 ;
19637 int arg3 = (int) 0 ;
19638 int arg4 = (int) 0 ;
19639 wxDateTime *result;
19640 PyObject * obj0 = 0 ;
19641 PyObject * obj1 = 0 ;
19642 PyObject * obj2 = 0 ;
19643 PyObject * obj3 = 0 ;
19644 char *kwnames[] = {
19645 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19646 };
19647
19648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19649 {
19650 arg1 = (int)(SWIG_As_int(obj0));
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 }
19653 if (obj1) {
19654 {
19655 arg2 = (int)(SWIG_As_int(obj1));
19656 if (SWIG_arg_fail(2)) SWIG_fail;
19657 }
19658 }
19659 if (obj2) {
19660 {
19661 arg3 = (int)(SWIG_As_int(obj2));
19662 if (SWIG_arg_fail(3)) SWIG_fail;
19663 }
19664 }
19665 if (obj3) {
19666 {
19667 arg4 = (int)(SWIG_As_int(obj3));
19668 if (SWIG_arg_fail(4)) SWIG_fail;
19669 }
19670 }
19671 {
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19674
19675 wxPyEndAllowThreads(__tstate);
19676 if (PyErr_Occurred()) SWIG_fail;
19677 }
19678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj;
19687 int arg1 ;
19688 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19689 int arg3 = (int) wxDateTime::Inv_Year ;
19690 int arg4 = (int) 0 ;
19691 int arg5 = (int) 0 ;
19692 int arg6 = (int) 0 ;
19693 int arg7 = (int) 0 ;
19694 wxDateTime *result;
19695 PyObject * obj0 = 0 ;
19696 PyObject * obj1 = 0 ;
19697 PyObject * obj2 = 0 ;
19698 PyObject * obj3 = 0 ;
19699 PyObject * obj4 = 0 ;
19700 PyObject * obj5 = 0 ;
19701 PyObject * obj6 = 0 ;
19702 char *kwnames[] = {
19703 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19704 };
19705
19706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19707 {
19708 arg1 = (int)(SWIG_As_int(obj0));
19709 if (SWIG_arg_fail(1)) SWIG_fail;
19710 }
19711 if (obj1) {
19712 {
19713 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19714 if (SWIG_arg_fail(2)) SWIG_fail;
19715 }
19716 }
19717 if (obj2) {
19718 {
19719 arg3 = (int)(SWIG_As_int(obj2));
19720 if (SWIG_arg_fail(3)) SWIG_fail;
19721 }
19722 }
19723 if (obj3) {
19724 {
19725 arg4 = (int)(SWIG_As_int(obj3));
19726 if (SWIG_arg_fail(4)) SWIG_fail;
19727 }
19728 }
19729 if (obj4) {
19730 {
19731 arg5 = (int)(SWIG_As_int(obj4));
19732 if (SWIG_arg_fail(5)) SWIG_fail;
19733 }
19734 }
19735 if (obj5) {
19736 {
19737 arg6 = (int)(SWIG_As_int(obj5));
19738 if (SWIG_arg_fail(6)) SWIG_fail;
19739 }
19740 }
19741 if (obj6) {
19742 {
19743 arg7 = (int)(SWIG_As_int(obj6));
19744 if (SWIG_arg_fail(7)) SWIG_fail;
19745 }
19746 }
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19750
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxDateTime *arg1 = (wxDateTime *) 0 ;
19764 PyObject * obj0 = 0 ;
19765 char *kwnames[] = {
19766 (char *) "self", NULL
19767 };
19768
19769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19771 if (SWIG_arg_fail(1)) SWIG_fail;
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 delete arg1;
19775
19776 wxPyEndAllowThreads(__tstate);
19777 if (PyErr_Occurred()) SWIG_fail;
19778 }
19779 Py_INCREF(Py_None); resultobj = Py_None;
19780 return resultobj;
19781 fail:
19782 return NULL;
19783 }
19784
19785
19786 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19787 PyObject *resultobj;
19788 wxDateTime *arg1 = (wxDateTime *) 0 ;
19789 wxDateTime *result;
19790 PyObject * obj0 = 0 ;
19791 char *kwnames[] = {
19792 (char *) "self", NULL
19793 };
19794
19795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19797 if (SWIG_arg_fail(1)) SWIG_fail;
19798 {
19799 PyThreadState* __tstate = wxPyBeginAllowThreads();
19800 {
19801 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19802 result = (wxDateTime *) &_result_ref;
19803 }
19804
19805 wxPyEndAllowThreads(__tstate);
19806 if (PyErr_Occurred()) SWIG_fail;
19807 }
19808 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19809 return resultobj;
19810 fail:
19811 return NULL;
19812 }
19813
19814
19815 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19816 PyObject *resultobj;
19817 wxDateTime *arg1 = (wxDateTime *) 0 ;
19818 time_t arg2 ;
19819 wxDateTime *result;
19820 PyObject * obj0 = 0 ;
19821 PyObject * obj1 = 0 ;
19822 char *kwnames[] = {
19823 (char *) "self",(char *) "timet", NULL
19824 };
19825
19826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19828 if (SWIG_arg_fail(1)) SWIG_fail;
19829 {
19830 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19831 if (SWIG_arg_fail(2)) SWIG_fail;
19832 }
19833 {
19834 PyThreadState* __tstate = wxPyBeginAllowThreads();
19835 {
19836 wxDateTime &_result_ref = (arg1)->Set(arg2);
19837 result = (wxDateTime *) &_result_ref;
19838 }
19839
19840 wxPyEndAllowThreads(__tstate);
19841 if (PyErr_Occurred()) SWIG_fail;
19842 }
19843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19844 return resultobj;
19845 fail:
19846 return NULL;
19847 }
19848
19849
19850 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19851 PyObject *resultobj;
19852 wxDateTime *arg1 = (wxDateTime *) 0 ;
19853 double arg2 ;
19854 wxDateTime *result;
19855 PyObject * obj0 = 0 ;
19856 PyObject * obj1 = 0 ;
19857 char *kwnames[] = {
19858 (char *) "self",(char *) "jdn", NULL
19859 };
19860
19861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19863 if (SWIG_arg_fail(1)) SWIG_fail;
19864 {
19865 arg2 = (double)(SWIG_As_double(obj1));
19866 if (SWIG_arg_fail(2)) SWIG_fail;
19867 }
19868 {
19869 PyThreadState* __tstate = wxPyBeginAllowThreads();
19870 {
19871 wxDateTime &_result_ref = (arg1)->Set(arg2);
19872 result = (wxDateTime *) &_result_ref;
19873 }
19874
19875 wxPyEndAllowThreads(__tstate);
19876 if (PyErr_Occurred()) SWIG_fail;
19877 }
19878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj;
19887 wxDateTime *arg1 = (wxDateTime *) 0 ;
19888 int arg2 ;
19889 int arg3 = (int) 0 ;
19890 int arg4 = (int) 0 ;
19891 int arg5 = (int) 0 ;
19892 wxDateTime *result;
19893 PyObject * obj0 = 0 ;
19894 PyObject * obj1 = 0 ;
19895 PyObject * obj2 = 0 ;
19896 PyObject * obj3 = 0 ;
19897 PyObject * obj4 = 0 ;
19898 char *kwnames[] = {
19899 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19900 };
19901
19902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19904 if (SWIG_arg_fail(1)) SWIG_fail;
19905 {
19906 arg2 = (int)(SWIG_As_int(obj1));
19907 if (SWIG_arg_fail(2)) SWIG_fail;
19908 }
19909 if (obj2) {
19910 {
19911 arg3 = (int)(SWIG_As_int(obj2));
19912 if (SWIG_arg_fail(3)) SWIG_fail;
19913 }
19914 }
19915 if (obj3) {
19916 {
19917 arg4 = (int)(SWIG_As_int(obj3));
19918 if (SWIG_arg_fail(4)) SWIG_fail;
19919 }
19920 }
19921 if (obj4) {
19922 {
19923 arg5 = (int)(SWIG_As_int(obj4));
19924 if (SWIG_arg_fail(5)) SWIG_fail;
19925 }
19926 }
19927 {
19928 PyThreadState* __tstate = wxPyBeginAllowThreads();
19929 {
19930 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19931 result = (wxDateTime *) &_result_ref;
19932 }
19933
19934 wxPyEndAllowThreads(__tstate);
19935 if (PyErr_Occurred()) SWIG_fail;
19936 }
19937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19938 return resultobj;
19939 fail:
19940 return NULL;
19941 }
19942
19943
19944 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19945 PyObject *resultobj;
19946 wxDateTime *arg1 = (wxDateTime *) 0 ;
19947 int arg2 ;
19948 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19949 int arg4 = (int) wxDateTime::Inv_Year ;
19950 int arg5 = (int) 0 ;
19951 int arg6 = (int) 0 ;
19952 int arg7 = (int) 0 ;
19953 int arg8 = (int) 0 ;
19954 wxDateTime *result;
19955 PyObject * obj0 = 0 ;
19956 PyObject * obj1 = 0 ;
19957 PyObject * obj2 = 0 ;
19958 PyObject * obj3 = 0 ;
19959 PyObject * obj4 = 0 ;
19960 PyObject * obj5 = 0 ;
19961 PyObject * obj6 = 0 ;
19962 PyObject * obj7 = 0 ;
19963 char *kwnames[] = {
19964 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19965 };
19966
19967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19969 if (SWIG_arg_fail(1)) SWIG_fail;
19970 {
19971 arg2 = (int)(SWIG_As_int(obj1));
19972 if (SWIG_arg_fail(2)) SWIG_fail;
19973 }
19974 if (obj2) {
19975 {
19976 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19977 if (SWIG_arg_fail(3)) SWIG_fail;
19978 }
19979 }
19980 if (obj3) {
19981 {
19982 arg4 = (int)(SWIG_As_int(obj3));
19983 if (SWIG_arg_fail(4)) SWIG_fail;
19984 }
19985 }
19986 if (obj4) {
19987 {
19988 arg5 = (int)(SWIG_As_int(obj4));
19989 if (SWIG_arg_fail(5)) SWIG_fail;
19990 }
19991 }
19992 if (obj5) {
19993 {
19994 arg6 = (int)(SWIG_As_int(obj5));
19995 if (SWIG_arg_fail(6)) SWIG_fail;
19996 }
19997 }
19998 if (obj6) {
19999 {
20000 arg7 = (int)(SWIG_As_int(obj6));
20001 if (SWIG_arg_fail(7)) SWIG_fail;
20002 }
20003 }
20004 if (obj7) {
20005 {
20006 arg8 = (int)(SWIG_As_int(obj7));
20007 if (SWIG_arg_fail(8)) SWIG_fail;
20008 }
20009 }
20010 {
20011 PyThreadState* __tstate = wxPyBeginAllowThreads();
20012 {
20013 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20014 result = (wxDateTime *) &_result_ref;
20015 }
20016
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj;
20029 wxDateTime *arg1 = (wxDateTime *) 0 ;
20030 wxDateTime *result;
20031 PyObject * obj0 = 0 ;
20032 char *kwnames[] = {
20033 (char *) "self", NULL
20034 };
20035
20036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20038 if (SWIG_arg_fail(1)) SWIG_fail;
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 {
20042 wxDateTime &_result_ref = (arg1)->ResetTime();
20043 result = (wxDateTime *) &_result_ref;
20044 }
20045
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj;
20058 wxDateTime *arg1 = (wxDateTime *) 0 ;
20059 int arg2 ;
20060 wxDateTime *result;
20061 PyObject * obj0 = 0 ;
20062 PyObject * obj1 = 0 ;
20063 char *kwnames[] = {
20064 (char *) "self",(char *) "year", NULL
20065 };
20066
20067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20069 if (SWIG_arg_fail(1)) SWIG_fail;
20070 {
20071 arg2 = (int)(SWIG_As_int(obj1));
20072 if (SWIG_arg_fail(2)) SWIG_fail;
20073 }
20074 {
20075 PyThreadState* __tstate = wxPyBeginAllowThreads();
20076 {
20077 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20078 result = (wxDateTime *) &_result_ref;
20079 }
20080
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20092 PyObject *resultobj;
20093 wxDateTime *arg1 = (wxDateTime *) 0 ;
20094 wxDateTime::Month arg2 ;
20095 wxDateTime *result;
20096 PyObject * obj0 = 0 ;
20097 PyObject * obj1 = 0 ;
20098 char *kwnames[] = {
20099 (char *) "self",(char *) "month", NULL
20100 };
20101
20102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20104 if (SWIG_arg_fail(1)) SWIG_fail;
20105 {
20106 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20107 if (SWIG_arg_fail(2)) SWIG_fail;
20108 }
20109 {
20110 PyThreadState* __tstate = wxPyBeginAllowThreads();
20111 {
20112 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20113 result = (wxDateTime *) &_result_ref;
20114 }
20115
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20127 PyObject *resultobj;
20128 wxDateTime *arg1 = (wxDateTime *) 0 ;
20129 int arg2 ;
20130 wxDateTime *result;
20131 PyObject * obj0 = 0 ;
20132 PyObject * obj1 = 0 ;
20133 char *kwnames[] = {
20134 (char *) "self",(char *) "day", NULL
20135 };
20136
20137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20139 if (SWIG_arg_fail(1)) SWIG_fail;
20140 {
20141 arg2 = (int)(SWIG_As_int(obj1));
20142 if (SWIG_arg_fail(2)) SWIG_fail;
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 {
20147 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20148 result = (wxDateTime *) &_result_ref;
20149 }
20150
20151 wxPyEndAllowThreads(__tstate);
20152 if (PyErr_Occurred()) SWIG_fail;
20153 }
20154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20155 return resultobj;
20156 fail:
20157 return NULL;
20158 }
20159
20160
20161 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20162 PyObject *resultobj;
20163 wxDateTime *arg1 = (wxDateTime *) 0 ;
20164 int arg2 ;
20165 wxDateTime *result;
20166 PyObject * obj0 = 0 ;
20167 PyObject * obj1 = 0 ;
20168 char *kwnames[] = {
20169 (char *) "self",(char *) "hour", NULL
20170 };
20171
20172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20174 if (SWIG_arg_fail(1)) SWIG_fail;
20175 {
20176 arg2 = (int)(SWIG_As_int(obj1));
20177 if (SWIG_arg_fail(2)) SWIG_fail;
20178 }
20179 {
20180 PyThreadState* __tstate = wxPyBeginAllowThreads();
20181 {
20182 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20183 result = (wxDateTime *) &_result_ref;
20184 }
20185
20186 wxPyEndAllowThreads(__tstate);
20187 if (PyErr_Occurred()) SWIG_fail;
20188 }
20189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20197 PyObject *resultobj;
20198 wxDateTime *arg1 = (wxDateTime *) 0 ;
20199 int arg2 ;
20200 wxDateTime *result;
20201 PyObject * obj0 = 0 ;
20202 PyObject * obj1 = 0 ;
20203 char *kwnames[] = {
20204 (char *) "self",(char *) "minute", NULL
20205 };
20206
20207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20209 if (SWIG_arg_fail(1)) SWIG_fail;
20210 {
20211 arg2 = (int)(SWIG_As_int(obj1));
20212 if (SWIG_arg_fail(2)) SWIG_fail;
20213 }
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 {
20217 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20218 result = (wxDateTime *) &_result_ref;
20219 }
20220
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20232 PyObject *resultobj;
20233 wxDateTime *arg1 = (wxDateTime *) 0 ;
20234 int arg2 ;
20235 wxDateTime *result;
20236 PyObject * obj0 = 0 ;
20237 PyObject * obj1 = 0 ;
20238 char *kwnames[] = {
20239 (char *) "self",(char *) "second", NULL
20240 };
20241
20242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20244 if (SWIG_arg_fail(1)) SWIG_fail;
20245 {
20246 arg2 = (int)(SWIG_As_int(obj1));
20247 if (SWIG_arg_fail(2)) SWIG_fail;
20248 }
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 {
20252 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20253 result = (wxDateTime *) &_result_ref;
20254 }
20255
20256 wxPyEndAllowThreads(__tstate);
20257 if (PyErr_Occurred()) SWIG_fail;
20258 }
20259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20260 return resultobj;
20261 fail:
20262 return NULL;
20263 }
20264
20265
20266 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20267 PyObject *resultobj;
20268 wxDateTime *arg1 = (wxDateTime *) 0 ;
20269 int arg2 ;
20270 wxDateTime *result;
20271 PyObject * obj0 = 0 ;
20272 PyObject * obj1 = 0 ;
20273 char *kwnames[] = {
20274 (char *) "self",(char *) "millisecond", NULL
20275 };
20276
20277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20279 if (SWIG_arg_fail(1)) SWIG_fail;
20280 {
20281 arg2 = (int)(SWIG_As_int(obj1));
20282 if (SWIG_arg_fail(2)) SWIG_fail;
20283 }
20284 {
20285 PyThreadState* __tstate = wxPyBeginAllowThreads();
20286 {
20287 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20288 result = (wxDateTime *) &_result_ref;
20289 }
20290
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj;
20303 wxDateTime *arg1 = (wxDateTime *) 0 ;
20304 wxDateTime::WeekDay arg2 ;
20305 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20306 wxDateTime *result;
20307 PyObject * obj0 = 0 ;
20308 PyObject * obj1 = 0 ;
20309 PyObject * obj2 = 0 ;
20310 char *kwnames[] = {
20311 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20312 };
20313
20314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20316 if (SWIG_arg_fail(1)) SWIG_fail;
20317 {
20318 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20319 if (SWIG_arg_fail(2)) SWIG_fail;
20320 }
20321 if (obj2) {
20322 {
20323 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20324 if (SWIG_arg_fail(3)) SWIG_fail;
20325 }
20326 }
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 {
20330 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20331 result = (wxDateTime *) &_result_ref;
20332 }
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20345 PyObject *resultobj;
20346 wxDateTime *arg1 = (wxDateTime *) 0 ;
20347 wxDateTime::WeekDay arg2 ;
20348 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20349 wxDateTime result;
20350 PyObject * obj0 = 0 ;
20351 PyObject * obj1 = 0 ;
20352 PyObject * obj2 = 0 ;
20353 char *kwnames[] = {
20354 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20355 };
20356
20357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20359 if (SWIG_arg_fail(1)) SWIG_fail;
20360 {
20361 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20362 if (SWIG_arg_fail(2)) SWIG_fail;
20363 }
20364 if (obj2) {
20365 {
20366 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20367 if (SWIG_arg_fail(3)) SWIG_fail;
20368 }
20369 }
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20373
20374 wxPyEndAllowThreads(__tstate);
20375 if (PyErr_Occurred()) SWIG_fail;
20376 }
20377 {
20378 wxDateTime * resultptr;
20379 resultptr = new wxDateTime((wxDateTime &)(result));
20380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20381 }
20382 return resultobj;
20383 fail:
20384 return NULL;
20385 }
20386
20387
20388 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20389 PyObject *resultobj;
20390 wxDateTime *arg1 = (wxDateTime *) 0 ;
20391 wxDateTime::WeekDay arg2 ;
20392 wxDateTime *result;
20393 PyObject * obj0 = 0 ;
20394 PyObject * obj1 = 0 ;
20395 char *kwnames[] = {
20396 (char *) "self",(char *) "weekday", NULL
20397 };
20398
20399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20401 if (SWIG_arg_fail(1)) SWIG_fail;
20402 {
20403 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20404 if (SWIG_arg_fail(2)) SWIG_fail;
20405 }
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 {
20409 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20410 result = (wxDateTime *) &_result_ref;
20411 }
20412
20413 wxPyEndAllowThreads(__tstate);
20414 if (PyErr_Occurred()) SWIG_fail;
20415 }
20416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20424 PyObject *resultobj;
20425 wxDateTime *arg1 = (wxDateTime *) 0 ;
20426 wxDateTime::WeekDay arg2 ;
20427 wxDateTime result;
20428 PyObject * obj0 = 0 ;
20429 PyObject * obj1 = 0 ;
20430 char *kwnames[] = {
20431 (char *) "self",(char *) "weekday", NULL
20432 };
20433
20434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20436 if (SWIG_arg_fail(1)) SWIG_fail;
20437 {
20438 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20439 if (SWIG_arg_fail(2)) SWIG_fail;
20440 }
20441 {
20442 PyThreadState* __tstate = wxPyBeginAllowThreads();
20443 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20444
20445 wxPyEndAllowThreads(__tstate);
20446 if (PyErr_Occurred()) SWIG_fail;
20447 }
20448 {
20449 wxDateTime * resultptr;
20450 resultptr = new wxDateTime((wxDateTime &)(result));
20451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20452 }
20453 return resultobj;
20454 fail:
20455 return NULL;
20456 }
20457
20458
20459 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20460 PyObject *resultobj;
20461 wxDateTime *arg1 = (wxDateTime *) 0 ;
20462 wxDateTime::WeekDay arg2 ;
20463 wxDateTime *result;
20464 PyObject * obj0 = 0 ;
20465 PyObject * obj1 = 0 ;
20466 char *kwnames[] = {
20467 (char *) "self",(char *) "weekday", NULL
20468 };
20469
20470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20472 if (SWIG_arg_fail(1)) SWIG_fail;
20473 {
20474 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20475 if (SWIG_arg_fail(2)) SWIG_fail;
20476 }
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 {
20480 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20481 result = (wxDateTime *) &_result_ref;
20482 }
20483
20484 wxPyEndAllowThreads(__tstate);
20485 if (PyErr_Occurred()) SWIG_fail;
20486 }
20487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20488 return resultobj;
20489 fail:
20490 return NULL;
20491 }
20492
20493
20494 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20495 PyObject *resultobj;
20496 wxDateTime *arg1 = (wxDateTime *) 0 ;
20497 wxDateTime::WeekDay arg2 ;
20498 wxDateTime result;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "self",(char *) "weekday", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 {
20509 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20510 if (SWIG_arg_fail(2)) SWIG_fail;
20511 }
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20515
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 {
20520 wxDateTime * resultptr;
20521 resultptr = new wxDateTime((wxDateTime &)(result));
20522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20523 }
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20531 PyObject *resultobj;
20532 wxDateTime *arg1 = (wxDateTime *) 0 ;
20533 wxDateTime::WeekDay arg2 ;
20534 int arg3 = (int) 1 ;
20535 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20536 int arg5 = (int) wxDateTime::Inv_Year ;
20537 bool result;
20538 PyObject * obj0 = 0 ;
20539 PyObject * obj1 = 0 ;
20540 PyObject * obj2 = 0 ;
20541 PyObject * obj3 = 0 ;
20542 PyObject * obj4 = 0 ;
20543 char *kwnames[] = {
20544 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20545 };
20546
20547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(1)) SWIG_fail;
20550 {
20551 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20552 if (SWIG_arg_fail(2)) SWIG_fail;
20553 }
20554 if (obj2) {
20555 {
20556 arg3 = (int)(SWIG_As_int(obj2));
20557 if (SWIG_arg_fail(3)) SWIG_fail;
20558 }
20559 }
20560 if (obj3) {
20561 {
20562 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20563 if (SWIG_arg_fail(4)) SWIG_fail;
20564 }
20565 }
20566 if (obj4) {
20567 {
20568 arg5 = (int)(SWIG_As_int(obj4));
20569 if (SWIG_arg_fail(5)) SWIG_fail;
20570 }
20571 }
20572 {
20573 PyThreadState* __tstate = wxPyBeginAllowThreads();
20574 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20575
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20589 PyObject *resultobj;
20590 wxDateTime *arg1 = (wxDateTime *) 0 ;
20591 wxDateTime::WeekDay arg2 ;
20592 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20593 int arg4 = (int) wxDateTime::Inv_Year ;
20594 bool result;
20595 PyObject * obj0 = 0 ;
20596 PyObject * obj1 = 0 ;
20597 PyObject * obj2 = 0 ;
20598 PyObject * obj3 = 0 ;
20599 char *kwnames[] = {
20600 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20601 };
20602
20603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20605 if (SWIG_arg_fail(1)) SWIG_fail;
20606 {
20607 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20608 if (SWIG_arg_fail(2)) SWIG_fail;
20609 }
20610 if (obj2) {
20611 {
20612 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20613 if (SWIG_arg_fail(3)) SWIG_fail;
20614 }
20615 }
20616 if (obj3) {
20617 {
20618 arg4 = (int)(SWIG_As_int(obj3));
20619 if (SWIG_arg_fail(4)) SWIG_fail;
20620 }
20621 }
20622 {
20623 PyThreadState* __tstate = wxPyBeginAllowThreads();
20624 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20625
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 {
20630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20631 }
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20639 PyObject *resultobj;
20640 wxDateTime *arg1 = (wxDateTime *) 0 ;
20641 wxDateTime::WeekDay arg2 ;
20642 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20643 int arg4 = (int) wxDateTime::Inv_Year ;
20644 wxDateTime result;
20645 PyObject * obj0 = 0 ;
20646 PyObject * obj1 = 0 ;
20647 PyObject * obj2 = 0 ;
20648 PyObject * obj3 = 0 ;
20649 char *kwnames[] = {
20650 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20651 };
20652
20653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20655 if (SWIG_arg_fail(1)) SWIG_fail;
20656 {
20657 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20658 if (SWIG_arg_fail(2)) SWIG_fail;
20659 }
20660 if (obj2) {
20661 {
20662 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20663 if (SWIG_arg_fail(3)) SWIG_fail;
20664 }
20665 }
20666 if (obj3) {
20667 {
20668 arg4 = (int)(SWIG_As_int(obj3));
20669 if (SWIG_arg_fail(4)) SWIG_fail;
20670 }
20671 }
20672 {
20673 PyThreadState* __tstate = wxPyBeginAllowThreads();
20674 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20675
20676 wxPyEndAllowThreads(__tstate);
20677 if (PyErr_Occurred()) SWIG_fail;
20678 }
20679 {
20680 wxDateTime * resultptr;
20681 resultptr = new wxDateTime((wxDateTime &)(result));
20682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20683 }
20684 return resultobj;
20685 fail:
20686 return NULL;
20687 }
20688
20689
20690 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20691 PyObject *resultobj;
20692 wxDateTime *arg1 = (wxDateTime *) 0 ;
20693 int arg2 ;
20694 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20695 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20696 bool result;
20697 PyObject * obj0 = 0 ;
20698 PyObject * obj1 = 0 ;
20699 PyObject * obj2 = 0 ;
20700 PyObject * obj3 = 0 ;
20701 char *kwnames[] = {
20702 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20703 };
20704
20705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20707 if (SWIG_arg_fail(1)) SWIG_fail;
20708 {
20709 arg2 = (int)(SWIG_As_int(obj1));
20710 if (SWIG_arg_fail(2)) SWIG_fail;
20711 }
20712 if (obj2) {
20713 {
20714 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20715 if (SWIG_arg_fail(3)) SWIG_fail;
20716 }
20717 }
20718 if (obj3) {
20719 {
20720 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20721 if (SWIG_arg_fail(4)) SWIG_fail;
20722 }
20723 }
20724 {
20725 PyThreadState* __tstate = wxPyBeginAllowThreads();
20726 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20727
20728 wxPyEndAllowThreads(__tstate);
20729 if (PyErr_Occurred()) SWIG_fail;
20730 }
20731 {
20732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20733 }
20734 return resultobj;
20735 fail:
20736 return NULL;
20737 }
20738
20739
20740 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20741 PyObject *resultobj;
20742 wxDateTime *arg1 = (wxDateTime *) 0 ;
20743 int arg2 ;
20744 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20745 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20746 wxDateTime result;
20747 PyObject * obj0 = 0 ;
20748 PyObject * obj1 = 0 ;
20749 PyObject * obj2 = 0 ;
20750 PyObject * obj3 = 0 ;
20751 char *kwnames[] = {
20752 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20753 };
20754
20755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20757 if (SWIG_arg_fail(1)) SWIG_fail;
20758 {
20759 arg2 = (int)(SWIG_As_int(obj1));
20760 if (SWIG_arg_fail(2)) SWIG_fail;
20761 }
20762 if (obj2) {
20763 {
20764 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20765 if (SWIG_arg_fail(3)) SWIG_fail;
20766 }
20767 }
20768 if (obj3) {
20769 {
20770 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20771 if (SWIG_arg_fail(4)) SWIG_fail;
20772 }
20773 }
20774 {
20775 PyThreadState* __tstate = wxPyBeginAllowThreads();
20776 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20777
20778 wxPyEndAllowThreads(__tstate);
20779 if (PyErr_Occurred()) SWIG_fail;
20780 }
20781 {
20782 wxDateTime * resultptr;
20783 resultptr = new wxDateTime((wxDateTime &)(result));
20784 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20785 }
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj;
20794 int arg1 ;
20795 int arg2 ;
20796 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20797 wxDateTime result;
20798 PyObject * obj0 = 0 ;
20799 PyObject * obj1 = 0 ;
20800 PyObject * obj2 = 0 ;
20801 char *kwnames[] = {
20802 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20803 };
20804
20805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20806 {
20807 arg1 = (int)(SWIG_As_int(obj0));
20808 if (SWIG_arg_fail(1)) SWIG_fail;
20809 }
20810 {
20811 arg2 = (int)(SWIG_As_int(obj1));
20812 if (SWIG_arg_fail(2)) SWIG_fail;
20813 }
20814 if (obj2) {
20815 {
20816 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20817 if (SWIG_arg_fail(3)) SWIG_fail;
20818 }
20819 }
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 wxDateTime * resultptr;
20829 resultptr = new wxDateTime((wxDateTime &)(result));
20830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20831 }
20832 return resultobj;
20833 fail:
20834 return NULL;
20835 }
20836
20837
20838 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20839 PyObject *resultobj;
20840 wxDateTime *arg1 = (wxDateTime *) 0 ;
20841 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20842 int arg3 = (int) wxDateTime::Inv_Year ;
20843 wxDateTime *result;
20844 PyObject * obj0 = 0 ;
20845 PyObject * obj1 = 0 ;
20846 PyObject * obj2 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "self",(char *) "month",(char *) "year", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20853 if (SWIG_arg_fail(1)) SWIG_fail;
20854 if (obj1) {
20855 {
20856 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20857 if (SWIG_arg_fail(2)) SWIG_fail;
20858 }
20859 }
20860 if (obj2) {
20861 {
20862 arg3 = (int)(SWIG_As_int(obj2));
20863 if (SWIG_arg_fail(3)) SWIG_fail;
20864 }
20865 }
20866 {
20867 PyThreadState* __tstate = wxPyBeginAllowThreads();
20868 {
20869 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20870 result = (wxDateTime *) &_result_ref;
20871 }
20872
20873 wxPyEndAllowThreads(__tstate);
20874 if (PyErr_Occurred()) SWIG_fail;
20875 }
20876 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20877 return resultobj;
20878 fail:
20879 return NULL;
20880 }
20881
20882
20883 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20884 PyObject *resultobj;
20885 wxDateTime *arg1 = (wxDateTime *) 0 ;
20886 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20887 int arg3 = (int) wxDateTime::Inv_Year ;
20888 wxDateTime result;
20889 PyObject * obj0 = 0 ;
20890 PyObject * obj1 = 0 ;
20891 PyObject * obj2 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "self",(char *) "month",(char *) "year", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20898 if (SWIG_arg_fail(1)) SWIG_fail;
20899 if (obj1) {
20900 {
20901 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20902 if (SWIG_arg_fail(2)) SWIG_fail;
20903 }
20904 }
20905 if (obj2) {
20906 {
20907 arg3 = (int)(SWIG_As_int(obj2));
20908 if (SWIG_arg_fail(3)) SWIG_fail;
20909 }
20910 }
20911 {
20912 PyThreadState* __tstate = wxPyBeginAllowThreads();
20913 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20914
20915 wxPyEndAllowThreads(__tstate);
20916 if (PyErr_Occurred()) SWIG_fail;
20917 }
20918 {
20919 wxDateTime * resultptr;
20920 resultptr = new wxDateTime((wxDateTime &)(result));
20921 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20922 }
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20930 PyObject *resultobj;
20931 wxDateTime *arg1 = (wxDateTime *) 0 ;
20932 int arg2 ;
20933 wxDateTime *result;
20934 PyObject * obj0 = 0 ;
20935 PyObject * obj1 = 0 ;
20936 char *kwnames[] = {
20937 (char *) "self",(char *) "yday", NULL
20938 };
20939
20940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20942 if (SWIG_arg_fail(1)) SWIG_fail;
20943 {
20944 arg2 = (int)(SWIG_As_int(obj1));
20945 if (SWIG_arg_fail(2)) SWIG_fail;
20946 }
20947 {
20948 PyThreadState* __tstate = wxPyBeginAllowThreads();
20949 {
20950 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20951 result = (wxDateTime *) &_result_ref;
20952 }
20953
20954 wxPyEndAllowThreads(__tstate);
20955 if (PyErr_Occurred()) SWIG_fail;
20956 }
20957 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20965 PyObject *resultobj;
20966 wxDateTime *arg1 = (wxDateTime *) 0 ;
20967 int arg2 ;
20968 wxDateTime result;
20969 PyObject * obj0 = 0 ;
20970 PyObject * obj1 = 0 ;
20971 char *kwnames[] = {
20972 (char *) "self",(char *) "yday", NULL
20973 };
20974
20975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20977 if (SWIG_arg_fail(1)) SWIG_fail;
20978 {
20979 arg2 = (int)(SWIG_As_int(obj1));
20980 if (SWIG_arg_fail(2)) SWIG_fail;
20981 }
20982 {
20983 PyThreadState* __tstate = wxPyBeginAllowThreads();
20984 result = (arg1)->GetYearDay(arg2);
20985
20986 wxPyEndAllowThreads(__tstate);
20987 if (PyErr_Occurred()) SWIG_fail;
20988 }
20989 {
20990 wxDateTime * resultptr;
20991 resultptr = new wxDateTime((wxDateTime &)(result));
20992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20993 }
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj;
21002 wxDateTime *arg1 = (wxDateTime *) 0 ;
21003 double result;
21004 PyObject * obj0 = 0 ;
21005 char *kwnames[] = {
21006 (char *) "self", NULL
21007 };
21008
21009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21011 if (SWIG_arg_fail(1)) SWIG_fail;
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 result = (double)(arg1)->GetJulianDayNumber();
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 resultobj = SWIG_From_double((double)(result));
21021 }
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21029 PyObject *resultobj;
21030 wxDateTime *arg1 = (wxDateTime *) 0 ;
21031 double result;
21032 PyObject * obj0 = 0 ;
21033 char *kwnames[] = {
21034 (char *) "self", NULL
21035 };
21036
21037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21039 if (SWIG_arg_fail(1)) SWIG_fail;
21040 {
21041 PyThreadState* __tstate = wxPyBeginAllowThreads();
21042 result = (double)(arg1)->GetJDN();
21043
21044 wxPyEndAllowThreads(__tstate);
21045 if (PyErr_Occurred()) SWIG_fail;
21046 }
21047 {
21048 resultobj = SWIG_From_double((double)(result));
21049 }
21050 return resultobj;
21051 fail:
21052 return NULL;
21053 }
21054
21055
21056 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21057 PyObject *resultobj;
21058 wxDateTime *arg1 = (wxDateTime *) 0 ;
21059 double result;
21060 PyObject * obj0 = 0 ;
21061 char *kwnames[] = {
21062 (char *) "self", NULL
21063 };
21064
21065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21067 if (SWIG_arg_fail(1)) SWIG_fail;
21068 {
21069 PyThreadState* __tstate = wxPyBeginAllowThreads();
21070 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21071
21072 wxPyEndAllowThreads(__tstate);
21073 if (PyErr_Occurred()) SWIG_fail;
21074 }
21075 {
21076 resultobj = SWIG_From_double((double)(result));
21077 }
21078 return resultobj;
21079 fail:
21080 return NULL;
21081 }
21082
21083
21084 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj;
21086 wxDateTime *arg1 = (wxDateTime *) 0 ;
21087 double result;
21088 PyObject * obj0 = 0 ;
21089 char *kwnames[] = {
21090 (char *) "self", NULL
21091 };
21092
21093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21095 if (SWIG_arg_fail(1)) SWIG_fail;
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 result = (double)(arg1)->GetMJD();
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 {
21104 resultobj = SWIG_From_double((double)(result));
21105 }
21106 return resultobj;
21107 fail:
21108 return NULL;
21109 }
21110
21111
21112 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21113 PyObject *resultobj;
21114 wxDateTime *arg1 = (wxDateTime *) 0 ;
21115 double result;
21116 PyObject * obj0 = 0 ;
21117 char *kwnames[] = {
21118 (char *) "self", NULL
21119 };
21120
21121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 {
21125 PyThreadState* __tstate = wxPyBeginAllowThreads();
21126 result = (double)(arg1)->GetRataDie();
21127
21128 wxPyEndAllowThreads(__tstate);
21129 if (PyErr_Occurred()) SWIG_fail;
21130 }
21131 {
21132 resultobj = SWIG_From_double((double)(result));
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21141 PyObject *resultobj;
21142 wxDateTime *arg1 = (wxDateTime *) 0 ;
21143 wxDateTime::TimeZone *arg2 = 0 ;
21144 bool arg3 = (bool) false ;
21145 wxDateTime result;
21146 bool temp2 = false ;
21147 PyObject * obj0 = 0 ;
21148 PyObject * obj1 = 0 ;
21149 PyObject * obj2 = 0 ;
21150 char *kwnames[] = {
21151 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21152 };
21153
21154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21156 if (SWIG_arg_fail(1)) SWIG_fail;
21157 {
21158 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21159 temp2 = true;
21160 }
21161 if (obj2) {
21162 {
21163 arg3 = (bool)(SWIG_As_bool(obj2));
21164 if (SWIG_arg_fail(3)) SWIG_fail;
21165 }
21166 }
21167 {
21168 PyThreadState* __tstate = wxPyBeginAllowThreads();
21169 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21170
21171 wxPyEndAllowThreads(__tstate);
21172 if (PyErr_Occurred()) SWIG_fail;
21173 }
21174 {
21175 wxDateTime * resultptr;
21176 resultptr = new wxDateTime((wxDateTime &)(result));
21177 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21178 }
21179 {
21180 if (temp2) delete arg2;
21181 }
21182 return resultobj;
21183 fail:
21184 {
21185 if (temp2) delete arg2;
21186 }
21187 return NULL;
21188 }
21189
21190
21191 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21192 PyObject *resultobj;
21193 wxDateTime *arg1 = (wxDateTime *) 0 ;
21194 wxDateTime::TimeZone *arg2 = 0 ;
21195 bool arg3 = (bool) false ;
21196 wxDateTime *result;
21197 bool temp2 = false ;
21198 PyObject * obj0 = 0 ;
21199 PyObject * obj1 = 0 ;
21200 PyObject * obj2 = 0 ;
21201 char *kwnames[] = {
21202 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21203 };
21204
21205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21207 if (SWIG_arg_fail(1)) SWIG_fail;
21208 {
21209 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21210 temp2 = true;
21211 }
21212 if (obj2) {
21213 {
21214 arg3 = (bool)(SWIG_As_bool(obj2));
21215 if (SWIG_arg_fail(3)) SWIG_fail;
21216 }
21217 }
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 {
21221 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21222 result = (wxDateTime *) &_result_ref;
21223 }
21224
21225 wxPyEndAllowThreads(__tstate);
21226 if (PyErr_Occurred()) SWIG_fail;
21227 }
21228 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21229 {
21230 if (temp2) delete arg2;
21231 }
21232 return resultobj;
21233 fail:
21234 {
21235 if (temp2) delete arg2;
21236 }
21237 return NULL;
21238 }
21239
21240
21241 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21242 PyObject *resultobj;
21243 wxDateTime *arg1 = (wxDateTime *) 0 ;
21244 bool arg2 = (bool) false ;
21245 wxDateTime result;
21246 PyObject * obj0 = 0 ;
21247 PyObject * obj1 = 0 ;
21248 char *kwnames[] = {
21249 (char *) "self",(char *) "noDST", NULL
21250 };
21251
21252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21254 if (SWIG_arg_fail(1)) SWIG_fail;
21255 if (obj1) {
21256 {
21257 arg2 = (bool)(SWIG_As_bool(obj1));
21258 if (SWIG_arg_fail(2)) SWIG_fail;
21259 }
21260 }
21261 {
21262 PyThreadState* __tstate = wxPyBeginAllowThreads();
21263 result = (arg1)->ToGMT(arg2);
21264
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 {
21269 wxDateTime * resultptr;
21270 resultptr = new wxDateTime((wxDateTime &)(result));
21271 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21272 }
21273 return resultobj;
21274 fail:
21275 return NULL;
21276 }
21277
21278
21279 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21280 PyObject *resultobj;
21281 wxDateTime *arg1 = (wxDateTime *) 0 ;
21282 bool arg2 = (bool) false ;
21283 wxDateTime *result;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self",(char *) "noDST", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 if (obj1) {
21294 {
21295 arg2 = (bool)(SWIG_As_bool(obj1));
21296 if (SWIG_arg_fail(2)) SWIG_fail;
21297 }
21298 }
21299 {
21300 PyThreadState* __tstate = wxPyBeginAllowThreads();
21301 {
21302 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21303 result = (wxDateTime *) &_result_ref;
21304 }
21305
21306 wxPyEndAllowThreads(__tstate);
21307 if (PyErr_Occurred()) SWIG_fail;
21308 }
21309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21310 return resultobj;
21311 fail:
21312 return NULL;
21313 }
21314
21315
21316 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21317 PyObject *resultobj;
21318 wxDateTime *arg1 = (wxDateTime *) 0 ;
21319 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21320 int result;
21321 PyObject * obj0 = 0 ;
21322 PyObject * obj1 = 0 ;
21323 char *kwnames[] = {
21324 (char *) "self",(char *) "country", NULL
21325 };
21326
21327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21329 if (SWIG_arg_fail(1)) SWIG_fail;
21330 if (obj1) {
21331 {
21332 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21333 if (SWIG_arg_fail(2)) SWIG_fail;
21334 }
21335 }
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 {
21344 resultobj = SWIG_From_int((int)(result));
21345 }
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21353 PyObject *resultobj;
21354 wxDateTime *arg1 = (wxDateTime *) 0 ;
21355 bool result;
21356 PyObject * obj0 = 0 ;
21357 char *kwnames[] = {
21358 (char *) "self", NULL
21359 };
21360
21361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21363 if (SWIG_arg_fail(1)) SWIG_fail;
21364 {
21365 PyThreadState* __tstate = wxPyBeginAllowThreads();
21366 result = (bool)((wxDateTime const *)arg1)->IsValid();
21367
21368 wxPyEndAllowThreads(__tstate);
21369 if (PyErr_Occurred()) SWIG_fail;
21370 }
21371 {
21372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21373 }
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj;
21382 wxDateTime *arg1 = (wxDateTime *) 0 ;
21383 time_t result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "self", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21391 if (SWIG_arg_fail(1)) SWIG_fail;
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21395
21396 wxPyEndAllowThreads(__tstate);
21397 if (PyErr_Occurred()) SWIG_fail;
21398 }
21399 {
21400 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21401 }
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21409 PyObject *resultobj;
21410 wxDateTime *arg1 = (wxDateTime *) 0 ;
21411 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21412 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21413 int result;
21414 bool temp2 = false ;
21415 PyObject * obj0 = 0 ;
21416 PyObject * obj1 = 0 ;
21417 char *kwnames[] = {
21418 (char *) "self",(char *) "tz", NULL
21419 };
21420
21421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21423 if (SWIG_arg_fail(1)) SWIG_fail;
21424 if (obj1) {
21425 {
21426 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21427 temp2 = true;
21428 }
21429 }
21430 {
21431 PyThreadState* __tstate = wxPyBeginAllowThreads();
21432 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21433
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 {
21438 resultobj = SWIG_From_int((int)(result));
21439 }
21440 {
21441 if (temp2) delete arg2;
21442 }
21443 return resultobj;
21444 fail:
21445 {
21446 if (temp2) delete arg2;
21447 }
21448 return NULL;
21449 }
21450
21451
21452 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21453 PyObject *resultobj;
21454 wxDateTime *arg1 = (wxDateTime *) 0 ;
21455 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21456 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21457 wxDateTime::Month result;
21458 bool temp2 = false ;
21459 PyObject * obj0 = 0 ;
21460 PyObject * obj1 = 0 ;
21461 char *kwnames[] = {
21462 (char *) "self",(char *) "tz", NULL
21463 };
21464
21465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21467 if (SWIG_arg_fail(1)) SWIG_fail;
21468 if (obj1) {
21469 {
21470 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21471 temp2 = true;
21472 }
21473 }
21474 {
21475 PyThreadState* __tstate = wxPyBeginAllowThreads();
21476 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21477
21478 wxPyEndAllowThreads(__tstate);
21479 if (PyErr_Occurred()) SWIG_fail;
21480 }
21481 resultobj = SWIG_From_int((result));
21482 {
21483 if (temp2) delete arg2;
21484 }
21485 return resultobj;
21486 fail:
21487 {
21488 if (temp2) delete arg2;
21489 }
21490 return NULL;
21491 }
21492
21493
21494 static PyObject *_wrap_DateTime_GetDay(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_GetDay",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)->GetDay((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_GetWeekDay(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::WeekDay 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_GetWeekDay",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::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((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_GetHour(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_GetHour",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)->GetHour((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_GetMinute(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 int 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_GetMinute",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 = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21649
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 {
21654 resultobj = SWIG_From_int((int)(result));
21655 }
21656 {
21657 if (temp2) delete arg2;
21658 }
21659 return resultobj;
21660 fail:
21661 {
21662 if (temp2) delete arg2;
21663 }
21664 return NULL;
21665 }
21666
21667
21668 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21669 PyObject *resultobj;
21670 wxDateTime *arg1 = (wxDateTime *) 0 ;
21671 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21672 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21673 int result;
21674 bool temp2 = false ;
21675 PyObject * obj0 = 0 ;
21676 PyObject * obj1 = 0 ;
21677 char *kwnames[] = {
21678 (char *) "self",(char *) "tz", NULL
21679 };
21680
21681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21683 if (SWIG_arg_fail(1)) SWIG_fail;
21684 if (obj1) {
21685 {
21686 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21687 temp2 = true;
21688 }
21689 }
21690 {
21691 PyThreadState* __tstate = wxPyBeginAllowThreads();
21692 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21693
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 {
21698 resultobj = SWIG_From_int((int)(result));
21699 }
21700 {
21701 if (temp2) delete arg2;
21702 }
21703 return resultobj;
21704 fail:
21705 {
21706 if (temp2) delete arg2;
21707 }
21708 return NULL;
21709 }
21710
21711
21712 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21713 PyObject *resultobj;
21714 wxDateTime *arg1 = (wxDateTime *) 0 ;
21715 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21716 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21717 int result;
21718 bool temp2 = false ;
21719 PyObject * obj0 = 0 ;
21720 PyObject * obj1 = 0 ;
21721 char *kwnames[] = {
21722 (char *) "self",(char *) "tz", NULL
21723 };
21724
21725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21727 if (SWIG_arg_fail(1)) SWIG_fail;
21728 if (obj1) {
21729 {
21730 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21731 temp2 = true;
21732 }
21733 }
21734 {
21735 PyThreadState* __tstate = wxPyBeginAllowThreads();
21736 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21737
21738 wxPyEndAllowThreads(__tstate);
21739 if (PyErr_Occurred()) SWIG_fail;
21740 }
21741 {
21742 resultobj = SWIG_From_int((int)(result));
21743 }
21744 {
21745 if (temp2) delete arg2;
21746 }
21747 return resultobj;
21748 fail:
21749 {
21750 if (temp2) delete arg2;
21751 }
21752 return NULL;
21753 }
21754
21755
21756 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21757 PyObject *resultobj;
21758 wxDateTime *arg1 = (wxDateTime *) 0 ;
21759 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21760 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21761 int result;
21762 bool temp2 = false ;
21763 PyObject * obj0 = 0 ;
21764 PyObject * obj1 = 0 ;
21765 char *kwnames[] = {
21766 (char *) "self",(char *) "tz", NULL
21767 };
21768
21769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21771 if (SWIG_arg_fail(1)) SWIG_fail;
21772 if (obj1) {
21773 {
21774 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21775 temp2 = true;
21776 }
21777 }
21778 {
21779 PyThreadState* __tstate = wxPyBeginAllowThreads();
21780 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21781
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 {
21786 resultobj = SWIG_From_int((int)(result));
21787 }
21788 {
21789 if (temp2) delete arg2;
21790 }
21791 return resultobj;
21792 fail:
21793 {
21794 if (temp2) delete arg2;
21795 }
21796 return NULL;
21797 }
21798
21799
21800 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj;
21802 wxDateTime *arg1 = (wxDateTime *) 0 ;
21803 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21804 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21805 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21806 int result;
21807 bool temp3 = false ;
21808 PyObject * obj0 = 0 ;
21809 PyObject * obj1 = 0 ;
21810 PyObject * obj2 = 0 ;
21811 char *kwnames[] = {
21812 (char *) "self",(char *) "flags",(char *) "tz", NULL
21813 };
21814
21815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21817 if (SWIG_arg_fail(1)) SWIG_fail;
21818 if (obj1) {
21819 {
21820 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21821 if (SWIG_arg_fail(2)) SWIG_fail;
21822 }
21823 }
21824 if (obj2) {
21825 {
21826 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21827 temp3 = true;
21828 }
21829 }
21830 {
21831 PyThreadState* __tstate = wxPyBeginAllowThreads();
21832 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21833
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 {
21838 resultobj = SWIG_From_int((int)(result));
21839 }
21840 {
21841 if (temp3) delete arg3;
21842 }
21843 return resultobj;
21844 fail:
21845 {
21846 if (temp3) delete arg3;
21847 }
21848 return NULL;
21849 }
21850
21851
21852 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj;
21854 wxDateTime *arg1 = (wxDateTime *) 0 ;
21855 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21856 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21857 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21858 int result;
21859 bool temp3 = false ;
21860 PyObject * obj0 = 0 ;
21861 PyObject * obj1 = 0 ;
21862 PyObject * obj2 = 0 ;
21863 char *kwnames[] = {
21864 (char *) "self",(char *) "flags",(char *) "tz", NULL
21865 };
21866
21867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21869 if (SWIG_arg_fail(1)) SWIG_fail;
21870 if (obj1) {
21871 {
21872 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21873 if (SWIG_arg_fail(2)) SWIG_fail;
21874 }
21875 }
21876 if (obj2) {
21877 {
21878 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21879 temp3 = true;
21880 }
21881 }
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21885
21886 wxPyEndAllowThreads(__tstate);
21887 if (PyErr_Occurred()) SWIG_fail;
21888 }
21889 {
21890 resultobj = SWIG_From_int((int)(result));
21891 }
21892 {
21893 if (temp3) delete arg3;
21894 }
21895 return resultobj;
21896 fail:
21897 {
21898 if (temp3) delete arg3;
21899 }
21900 return NULL;
21901 }
21902
21903
21904 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21905 PyObject *resultobj;
21906 wxDateTime *arg1 = (wxDateTime *) 0 ;
21907 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21908 bool result;
21909 PyObject * obj0 = 0 ;
21910 PyObject * obj1 = 0 ;
21911 char *kwnames[] = {
21912 (char *) "self",(char *) "country", NULL
21913 };
21914
21915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21917 if (SWIG_arg_fail(1)) SWIG_fail;
21918 if (obj1) {
21919 {
21920 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21921 if (SWIG_arg_fail(2)) SWIG_fail;
21922 }
21923 }
21924 {
21925 PyThreadState* __tstate = wxPyBeginAllowThreads();
21926 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21927
21928 wxPyEndAllowThreads(__tstate);
21929 if (PyErr_Occurred()) SWIG_fail;
21930 }
21931 {
21932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21933 }
21934 return resultobj;
21935 fail:
21936 return NULL;
21937 }
21938
21939
21940 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21941 PyObject *resultobj;
21942 wxDateTime *arg1 = (wxDateTime *) 0 ;
21943 wxDateTime *arg2 = 0 ;
21944 bool result;
21945 PyObject * obj0 = 0 ;
21946 PyObject * obj1 = 0 ;
21947 char *kwnames[] = {
21948 (char *) "self",(char *) "datetime", NULL
21949 };
21950
21951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21953 if (SWIG_arg_fail(1)) SWIG_fail;
21954 {
21955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21956 if (SWIG_arg_fail(2)) SWIG_fail;
21957 if (arg2 == NULL) {
21958 SWIG_null_ref("wxDateTime");
21959 }
21960 if (SWIG_arg_fail(2)) SWIG_fail;
21961 }
21962 {
21963 PyThreadState* __tstate = wxPyBeginAllowThreads();
21964 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21965
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 {
21970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21971 }
21972 return resultobj;
21973 fail:
21974 return NULL;
21975 }
21976
21977
21978 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 wxDateTime *arg1 = (wxDateTime *) 0 ;
21981 wxDateTime *arg2 = 0 ;
21982 bool result;
21983 PyObject * obj0 = 0 ;
21984 PyObject * obj1 = 0 ;
21985 char *kwnames[] = {
21986 (char *) "self",(char *) "datetime", NULL
21987 };
21988
21989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21991 if (SWIG_arg_fail(1)) SWIG_fail;
21992 {
21993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21994 if (SWIG_arg_fail(2)) SWIG_fail;
21995 if (arg2 == NULL) {
21996 SWIG_null_ref("wxDateTime");
21997 }
21998 if (SWIG_arg_fail(2)) SWIG_fail;
21999 }
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22003
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 {
22008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22009 }
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22017 PyObject *resultobj;
22018 wxDateTime *arg1 = (wxDateTime *) 0 ;
22019 wxDateTime *arg2 = 0 ;
22020 bool result;
22021 PyObject * obj0 = 0 ;
22022 PyObject * obj1 = 0 ;
22023 char *kwnames[] = {
22024 (char *) "self",(char *) "datetime", NULL
22025 };
22026
22027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22029 if (SWIG_arg_fail(1)) SWIG_fail;
22030 {
22031 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22032 if (SWIG_arg_fail(2)) SWIG_fail;
22033 if (arg2 == NULL) {
22034 SWIG_null_ref("wxDateTime");
22035 }
22036 if (SWIG_arg_fail(2)) SWIG_fail;
22037 }
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22041
22042 wxPyEndAllowThreads(__tstate);
22043 if (PyErr_Occurred()) SWIG_fail;
22044 }
22045 {
22046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22047 }
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22055 PyObject *resultobj;
22056 wxDateTime *arg1 = (wxDateTime *) 0 ;
22057 wxDateTime *arg2 = 0 ;
22058 wxDateTime *arg3 = 0 ;
22059 bool result;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 PyObject * obj2 = 0 ;
22063 char *kwnames[] = {
22064 (char *) "self",(char *) "t1",(char *) "t2", NULL
22065 };
22066
22067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(1)) SWIG_fail;
22070 {
22071 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22072 if (SWIG_arg_fail(2)) SWIG_fail;
22073 if (arg2 == NULL) {
22074 SWIG_null_ref("wxDateTime");
22075 }
22076 if (SWIG_arg_fail(2)) SWIG_fail;
22077 }
22078 {
22079 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(3)) SWIG_fail;
22081 if (arg3 == NULL) {
22082 SWIG_null_ref("wxDateTime");
22083 }
22084 if (SWIG_arg_fail(3)) SWIG_fail;
22085 }
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
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_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22103 PyObject *resultobj;
22104 wxDateTime *arg1 = (wxDateTime *) 0 ;
22105 wxDateTime *arg2 = 0 ;
22106 wxDateTime *arg3 = 0 ;
22107 bool result;
22108 PyObject * obj0 = 0 ;
22109 PyObject * obj1 = 0 ;
22110 PyObject * obj2 = 0 ;
22111 char *kwnames[] = {
22112 (char *) "self",(char *) "t1",(char *) "t2", NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(1)) SWIG_fail;
22118 {
22119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22120 if (SWIG_arg_fail(2)) SWIG_fail;
22121 if (arg2 == NULL) {
22122 SWIG_null_ref("wxDateTime");
22123 }
22124 if (SWIG_arg_fail(2)) SWIG_fail;
22125 }
22126 {
22127 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22128 if (SWIG_arg_fail(3)) SWIG_fail;
22129 if (arg3 == NULL) {
22130 SWIG_null_ref("wxDateTime");
22131 }
22132 if (SWIG_arg_fail(3)) SWIG_fail;
22133 }
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22137
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 {
22142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22143 }
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj;
22152 wxDateTime *arg1 = (wxDateTime *) 0 ;
22153 wxDateTime *arg2 = 0 ;
22154 bool result;
22155 PyObject * obj0 = 0 ;
22156 PyObject * obj1 = 0 ;
22157 char *kwnames[] = {
22158 (char *) "self",(char *) "dt", NULL
22159 };
22160
22161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22163 if (SWIG_arg_fail(1)) SWIG_fail;
22164 {
22165 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22166 if (SWIG_arg_fail(2)) SWIG_fail;
22167 if (arg2 == NULL) {
22168 SWIG_null_ref("wxDateTime");
22169 }
22170 if (SWIG_arg_fail(2)) SWIG_fail;
22171 }
22172 {
22173 PyThreadState* __tstate = wxPyBeginAllowThreads();
22174 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
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_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxDateTime *arg1 = (wxDateTime *) 0 ;
22191 wxDateTime *arg2 = 0 ;
22192 bool result;
22193 PyObject * obj0 = 0 ;
22194 PyObject * obj1 = 0 ;
22195 char *kwnames[] = {
22196 (char *) "self",(char *) "dt", NULL
22197 };
22198
22199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22201 if (SWIG_arg_fail(1)) SWIG_fail;
22202 {
22203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22204 if (SWIG_arg_fail(2)) SWIG_fail;
22205 if (arg2 == NULL) {
22206 SWIG_null_ref("wxDateTime");
22207 }
22208 if (SWIG_arg_fail(2)) SWIG_fail;
22209 }
22210 {
22211 PyThreadState* __tstate = wxPyBeginAllowThreads();
22212 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22213
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 {
22218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22219 }
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22227 PyObject *resultobj;
22228 wxDateTime *arg1 = (wxDateTime *) 0 ;
22229 wxDateTime *arg2 = 0 ;
22230 wxTimeSpan *arg3 = 0 ;
22231 bool result;
22232 PyObject * obj0 = 0 ;
22233 PyObject * obj1 = 0 ;
22234 PyObject * obj2 = 0 ;
22235 char *kwnames[] = {
22236 (char *) "self",(char *) "dt",(char *) "ts", NULL
22237 };
22238
22239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(1)) SWIG_fail;
22242 {
22243 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22244 if (SWIG_arg_fail(2)) SWIG_fail;
22245 if (arg2 == NULL) {
22246 SWIG_null_ref("wxDateTime");
22247 }
22248 if (SWIG_arg_fail(2)) SWIG_fail;
22249 }
22250 {
22251 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22252 if (SWIG_arg_fail(3)) SWIG_fail;
22253 if (arg3 == NULL) {
22254 SWIG_null_ref("wxTimeSpan");
22255 }
22256 if (SWIG_arg_fail(3)) SWIG_fail;
22257 }
22258 {
22259 PyThreadState* __tstate = wxPyBeginAllowThreads();
22260 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
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_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj;
22276 wxDateTime *arg1 = (wxDateTime *) 0 ;
22277 wxTimeSpan *arg2 = 0 ;
22278 wxDateTime *result;
22279 PyObject * obj0 = 0 ;
22280 PyObject * obj1 = 0 ;
22281 char *kwnames[] = {
22282 (char *) "self",(char *) "diff", NULL
22283 };
22284
22285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",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_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22290 if (SWIG_arg_fail(2)) SWIG_fail;
22291 if (arg2 == NULL) {
22292 SWIG_null_ref("wxTimeSpan");
22293 }
22294 if (SWIG_arg_fail(2)) SWIG_fail;
22295 }
22296 {
22297 PyThreadState* __tstate = wxPyBeginAllowThreads();
22298 {
22299 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22300 result = (wxDateTime *) &_result_ref;
22301 }
22302
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22307 return resultobj;
22308 fail:
22309 return NULL;
22310 }
22311
22312
22313 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj;
22315 wxDateTime *arg1 = (wxDateTime *) 0 ;
22316 wxDateSpan *arg2 = 0 ;
22317 wxDateTime *result;
22318 PyObject * obj0 = 0 ;
22319 PyObject * obj1 = 0 ;
22320 char *kwnames[] = {
22321 (char *) "self",(char *) "diff", NULL
22322 };
22323
22324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22326 if (SWIG_arg_fail(1)) SWIG_fail;
22327 {
22328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22329 if (SWIG_arg_fail(2)) SWIG_fail;
22330 if (arg2 == NULL) {
22331 SWIG_null_ref("wxDateSpan");
22332 }
22333 if (SWIG_arg_fail(2)) SWIG_fail;
22334 }
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 {
22338 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22339 result = (wxDateTime *) &_result_ref;
22340 }
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxDateTime *arg1 = (wxDateTime *) 0 ;
22355 wxTimeSpan *arg2 = 0 ;
22356 wxDateTime *result;
22357 PyObject * obj0 = 0 ;
22358 PyObject * obj1 = 0 ;
22359 char *kwnames[] = {
22360 (char *) "self",(char *) "diff", NULL
22361 };
22362
22363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22365 if (SWIG_arg_fail(1)) SWIG_fail;
22366 {
22367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22368 if (SWIG_arg_fail(2)) SWIG_fail;
22369 if (arg2 == NULL) {
22370 SWIG_null_ref("wxTimeSpan");
22371 }
22372 if (SWIG_arg_fail(2)) SWIG_fail;
22373 }
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 {
22377 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22378 result = (wxDateTime *) &_result_ref;
22379 }
22380
22381 wxPyEndAllowThreads(__tstate);
22382 if (PyErr_Occurred()) SWIG_fail;
22383 }
22384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22392 PyObject *resultobj;
22393 wxDateTime *arg1 = (wxDateTime *) 0 ;
22394 wxDateSpan *arg2 = 0 ;
22395 wxDateTime *result;
22396 PyObject * obj0 = 0 ;
22397 PyObject * obj1 = 0 ;
22398 char *kwnames[] = {
22399 (char *) "self",(char *) "diff", NULL
22400 };
22401
22402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22404 if (SWIG_arg_fail(1)) SWIG_fail;
22405 {
22406 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22407 if (SWIG_arg_fail(2)) SWIG_fail;
22408 if (arg2 == NULL) {
22409 SWIG_null_ref("wxDateSpan");
22410 }
22411 if (SWIG_arg_fail(2)) SWIG_fail;
22412 }
22413 {
22414 PyThreadState* __tstate = wxPyBeginAllowThreads();
22415 {
22416 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22417 result = (wxDateTime *) &_result_ref;
22418 }
22419
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj;
22432 wxDateTime *arg1 = (wxDateTime *) 0 ;
22433 wxDateTime *arg2 = 0 ;
22434 wxTimeSpan result;
22435 PyObject * obj0 = 0 ;
22436 PyObject * obj1 = 0 ;
22437 char *kwnames[] = {
22438 (char *) "self",(char *) "dt", NULL
22439 };
22440
22441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22443 if (SWIG_arg_fail(1)) SWIG_fail;
22444 {
22445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22446 if (SWIG_arg_fail(2)) SWIG_fail;
22447 if (arg2 == NULL) {
22448 SWIG_null_ref("wxDateTime");
22449 }
22450 if (SWIG_arg_fail(2)) SWIG_fail;
22451 }
22452 {
22453 PyThreadState* __tstate = wxPyBeginAllowThreads();
22454 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22455
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 {
22460 wxTimeSpan * resultptr;
22461 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22462 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22463 }
22464 return resultobj;
22465 fail:
22466 return NULL;
22467 }
22468
22469
22470 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22471 PyObject *resultobj;
22472 wxDateTime *arg1 = (wxDateTime *) 0 ;
22473 wxTimeSpan *arg2 = 0 ;
22474 wxDateTime *result;
22475 PyObject * obj0 = 0 ;
22476 PyObject * obj1 = 0 ;
22477
22478 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22480 if (SWIG_arg_fail(1)) SWIG_fail;
22481 {
22482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22483 if (SWIG_arg_fail(2)) SWIG_fail;
22484 if (arg2 == NULL) {
22485 SWIG_null_ref("wxTimeSpan");
22486 }
22487 if (SWIG_arg_fail(2)) SWIG_fail;
22488 }
22489 {
22490 PyThreadState* __tstate = wxPyBeginAllowThreads();
22491 {
22492 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22493 result = (wxDateTime *) &_result_ref;
22494 }
22495
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22507 PyObject *resultobj;
22508 wxDateTime *arg1 = (wxDateTime *) 0 ;
22509 wxDateSpan *arg2 = 0 ;
22510 wxDateTime *result;
22511 PyObject * obj0 = 0 ;
22512 PyObject * obj1 = 0 ;
22513
22514 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22516 if (SWIG_arg_fail(1)) SWIG_fail;
22517 {
22518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22519 if (SWIG_arg_fail(2)) SWIG_fail;
22520 if (arg2 == NULL) {
22521 SWIG_null_ref("wxDateSpan");
22522 }
22523 if (SWIG_arg_fail(2)) SWIG_fail;
22524 }
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 {
22528 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22529 result = (wxDateTime *) &_result_ref;
22530 }
22531
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22543 int argc;
22544 PyObject *argv[3];
22545 int ii;
22546
22547 argc = PyObject_Length(args);
22548 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22549 argv[ii] = PyTuple_GetItem(args,ii);
22550 }
22551 if (argc == 2) {
22552 int _v;
22553 {
22554 void *ptr;
22555 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22556 _v = 0;
22557 PyErr_Clear();
22558 } else {
22559 _v = 1;
22560 }
22561 }
22562 if (_v) {
22563 {
22564 void *ptr = 0;
22565 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22566 _v = 0;
22567 PyErr_Clear();
22568 } else {
22569 _v = (ptr != 0);
22570 }
22571 }
22572 if (_v) {
22573 return _wrap_DateTime___iadd____SWIG_0(self,args);
22574 }
22575 }
22576 }
22577 if (argc == 2) {
22578 int _v;
22579 {
22580 void *ptr;
22581 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22582 _v = 0;
22583 PyErr_Clear();
22584 } else {
22585 _v = 1;
22586 }
22587 }
22588 if (_v) {
22589 {
22590 void *ptr = 0;
22591 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22592 _v = 0;
22593 PyErr_Clear();
22594 } else {
22595 _v = (ptr != 0);
22596 }
22597 }
22598 if (_v) {
22599 return _wrap_DateTime___iadd____SWIG_1(self,args);
22600 }
22601 }
22602 }
22603
22604 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22605 return NULL;
22606 }
22607
22608
22609 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22610 PyObject *resultobj;
22611 wxDateTime *arg1 = (wxDateTime *) 0 ;
22612 wxTimeSpan *arg2 = 0 ;
22613 wxDateTime *result;
22614 PyObject * obj0 = 0 ;
22615 PyObject * obj1 = 0 ;
22616
22617 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22619 if (SWIG_arg_fail(1)) SWIG_fail;
22620 {
22621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22622 if (SWIG_arg_fail(2)) SWIG_fail;
22623 if (arg2 == NULL) {
22624 SWIG_null_ref("wxTimeSpan");
22625 }
22626 if (SWIG_arg_fail(2)) SWIG_fail;
22627 }
22628 {
22629 PyThreadState* __tstate = wxPyBeginAllowThreads();
22630 {
22631 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22632 result = (wxDateTime *) &_result_ref;
22633 }
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22646 PyObject *resultobj;
22647 wxDateTime *arg1 = (wxDateTime *) 0 ;
22648 wxDateSpan *arg2 = 0 ;
22649 wxDateTime *result;
22650 PyObject * obj0 = 0 ;
22651 PyObject * obj1 = 0 ;
22652
22653 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22655 if (SWIG_arg_fail(1)) SWIG_fail;
22656 {
22657 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22658 if (SWIG_arg_fail(2)) SWIG_fail;
22659 if (arg2 == NULL) {
22660 SWIG_null_ref("wxDateSpan");
22661 }
22662 if (SWIG_arg_fail(2)) SWIG_fail;
22663 }
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 {
22667 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22668 result = (wxDateTime *) &_result_ref;
22669 }
22670
22671 wxPyEndAllowThreads(__tstate);
22672 if (PyErr_Occurred()) SWIG_fail;
22673 }
22674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22682 int argc;
22683 PyObject *argv[3];
22684 int ii;
22685
22686 argc = PyObject_Length(args);
22687 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22688 argv[ii] = PyTuple_GetItem(args,ii);
22689 }
22690 if (argc == 2) {
22691 int _v;
22692 {
22693 void *ptr;
22694 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22695 _v = 0;
22696 PyErr_Clear();
22697 } else {
22698 _v = 1;
22699 }
22700 }
22701 if (_v) {
22702 {
22703 void *ptr = 0;
22704 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22705 _v = 0;
22706 PyErr_Clear();
22707 } else {
22708 _v = (ptr != 0);
22709 }
22710 }
22711 if (_v) {
22712 return _wrap_DateTime___isub____SWIG_0(self,args);
22713 }
22714 }
22715 }
22716 if (argc == 2) {
22717 int _v;
22718 {
22719 void *ptr;
22720 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22721 _v = 0;
22722 PyErr_Clear();
22723 } else {
22724 _v = 1;
22725 }
22726 }
22727 if (_v) {
22728 {
22729 void *ptr = 0;
22730 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22731 _v = 0;
22732 PyErr_Clear();
22733 } else {
22734 _v = (ptr != 0);
22735 }
22736 }
22737 if (_v) {
22738 return _wrap_DateTime___isub____SWIG_1(self,args);
22739 }
22740 }
22741 }
22742
22743 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22744 return NULL;
22745 }
22746
22747
22748 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22749 PyObject *resultobj;
22750 wxDateTime *arg1 = (wxDateTime *) 0 ;
22751 wxTimeSpan *arg2 = 0 ;
22752 wxDateTime result;
22753 PyObject * obj0 = 0 ;
22754 PyObject * obj1 = 0 ;
22755
22756 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22758 if (SWIG_arg_fail(1)) SWIG_fail;
22759 {
22760 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22761 if (SWIG_arg_fail(2)) SWIG_fail;
22762 if (arg2 == NULL) {
22763 SWIG_null_ref("wxTimeSpan");
22764 }
22765 if (SWIG_arg_fail(2)) SWIG_fail;
22766 }
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22770
22771 wxPyEndAllowThreads(__tstate);
22772 if (PyErr_Occurred()) SWIG_fail;
22773 }
22774 {
22775 wxDateTime * resultptr;
22776 resultptr = new wxDateTime((wxDateTime &)(result));
22777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22778 }
22779 return resultobj;
22780 fail:
22781 return NULL;
22782 }
22783
22784
22785 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22786 PyObject *resultobj;
22787 wxDateTime *arg1 = (wxDateTime *) 0 ;
22788 wxDateSpan *arg2 = 0 ;
22789 wxDateTime result;
22790 PyObject * obj0 = 0 ;
22791 PyObject * obj1 = 0 ;
22792
22793 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(1)) SWIG_fail;
22796 {
22797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22798 if (SWIG_arg_fail(2)) SWIG_fail;
22799 if (arg2 == NULL) {
22800 SWIG_null_ref("wxDateSpan");
22801 }
22802 if (SWIG_arg_fail(2)) SWIG_fail;
22803 }
22804 {
22805 PyThreadState* __tstate = wxPyBeginAllowThreads();
22806 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22807
22808 wxPyEndAllowThreads(__tstate);
22809 if (PyErr_Occurred()) SWIG_fail;
22810 }
22811 {
22812 wxDateTime * resultptr;
22813 resultptr = new wxDateTime((wxDateTime &)(result));
22814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22815 }
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22823 int argc;
22824 PyObject *argv[3];
22825 int ii;
22826
22827 argc = PyObject_Length(args);
22828 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22829 argv[ii] = PyTuple_GetItem(args,ii);
22830 }
22831 if (argc == 2) {
22832 int _v;
22833 {
22834 void *ptr;
22835 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22836 _v = 0;
22837 PyErr_Clear();
22838 } else {
22839 _v = 1;
22840 }
22841 }
22842 if (_v) {
22843 {
22844 void *ptr = 0;
22845 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22846 _v = 0;
22847 PyErr_Clear();
22848 } else {
22849 _v = (ptr != 0);
22850 }
22851 }
22852 if (_v) {
22853 return _wrap_DateTime___add____SWIG_0(self,args);
22854 }
22855 }
22856 }
22857 if (argc == 2) {
22858 int _v;
22859 {
22860 void *ptr;
22861 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22862 _v = 0;
22863 PyErr_Clear();
22864 } else {
22865 _v = 1;
22866 }
22867 }
22868 if (_v) {
22869 {
22870 void *ptr = 0;
22871 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22872 _v = 0;
22873 PyErr_Clear();
22874 } else {
22875 _v = (ptr != 0);
22876 }
22877 }
22878 if (_v) {
22879 return _wrap_DateTime___add____SWIG_1(self,args);
22880 }
22881 }
22882 }
22883
22884 Py_INCREF(Py_NotImplemented);
22885 return Py_NotImplemented;
22886 }
22887
22888
22889 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22890 PyObject *resultobj;
22891 wxDateTime *arg1 = (wxDateTime *) 0 ;
22892 wxDateTime *arg2 = 0 ;
22893 wxTimeSpan result;
22894 PyObject * obj0 = 0 ;
22895 PyObject * obj1 = 0 ;
22896
22897 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22899 if (SWIG_arg_fail(1)) SWIG_fail;
22900 {
22901 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22902 if (SWIG_arg_fail(2)) SWIG_fail;
22903 if (arg2 == NULL) {
22904 SWIG_null_ref("wxDateTime");
22905 }
22906 if (SWIG_arg_fail(2)) SWIG_fail;
22907 }
22908 {
22909 PyThreadState* __tstate = wxPyBeginAllowThreads();
22910 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22911
22912 wxPyEndAllowThreads(__tstate);
22913 if (PyErr_Occurred()) SWIG_fail;
22914 }
22915 {
22916 wxTimeSpan * resultptr;
22917 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22919 }
22920 return resultobj;
22921 fail:
22922 return NULL;
22923 }
22924
22925
22926 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22927 PyObject *resultobj;
22928 wxDateTime *arg1 = (wxDateTime *) 0 ;
22929 wxTimeSpan *arg2 = 0 ;
22930 wxDateTime result;
22931 PyObject * obj0 = 0 ;
22932 PyObject * obj1 = 0 ;
22933
22934 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22936 if (SWIG_arg_fail(1)) SWIG_fail;
22937 {
22938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22939 if (SWIG_arg_fail(2)) SWIG_fail;
22940 if (arg2 == NULL) {
22941 SWIG_null_ref("wxTimeSpan");
22942 }
22943 if (SWIG_arg_fail(2)) SWIG_fail;
22944 }
22945 {
22946 PyThreadState* __tstate = wxPyBeginAllowThreads();
22947 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22948
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 {
22953 wxDateTime * resultptr;
22954 resultptr = new wxDateTime((wxDateTime &)(result));
22955 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22956 }
22957 return resultobj;
22958 fail:
22959 return NULL;
22960 }
22961
22962
22963 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22964 PyObject *resultobj;
22965 wxDateTime *arg1 = (wxDateTime *) 0 ;
22966 wxDateSpan *arg2 = 0 ;
22967 wxDateTime result;
22968 PyObject * obj0 = 0 ;
22969 PyObject * obj1 = 0 ;
22970
22971 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22973 if (SWIG_arg_fail(1)) SWIG_fail;
22974 {
22975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22976 if (SWIG_arg_fail(2)) SWIG_fail;
22977 if (arg2 == NULL) {
22978 SWIG_null_ref("wxDateSpan");
22979 }
22980 if (SWIG_arg_fail(2)) SWIG_fail;
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22985
22986 wxPyEndAllowThreads(__tstate);
22987 if (PyErr_Occurred()) SWIG_fail;
22988 }
22989 {
22990 wxDateTime * resultptr;
22991 resultptr = new wxDateTime((wxDateTime &)(result));
22992 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22993 }
22994 return resultobj;
22995 fail:
22996 return NULL;
22997 }
22998
22999
23000 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23001 int argc;
23002 PyObject *argv[3];
23003 int ii;
23004
23005 argc = PyObject_Length(args);
23006 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23007 argv[ii] = PyTuple_GetItem(args,ii);
23008 }
23009 if (argc == 2) {
23010 int _v;
23011 {
23012 void *ptr;
23013 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23014 _v = 0;
23015 PyErr_Clear();
23016 } else {
23017 _v = 1;
23018 }
23019 }
23020 if (_v) {
23021 {
23022 void *ptr = 0;
23023 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23024 _v = 0;
23025 PyErr_Clear();
23026 } else {
23027 _v = (ptr != 0);
23028 }
23029 }
23030 if (_v) {
23031 return _wrap_DateTime___sub____SWIG_0(self,args);
23032 }
23033 }
23034 }
23035 if (argc == 2) {
23036 int _v;
23037 {
23038 void *ptr;
23039 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23040 _v = 0;
23041 PyErr_Clear();
23042 } else {
23043 _v = 1;
23044 }
23045 }
23046 if (_v) {
23047 {
23048 void *ptr = 0;
23049 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23050 _v = 0;
23051 PyErr_Clear();
23052 } else {
23053 _v = (ptr != 0);
23054 }
23055 }
23056 if (_v) {
23057 return _wrap_DateTime___sub____SWIG_1(self,args);
23058 }
23059 }
23060 }
23061 if (argc == 2) {
23062 int _v;
23063 {
23064 void *ptr;
23065 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23066 _v = 0;
23067 PyErr_Clear();
23068 } else {
23069 _v = 1;
23070 }
23071 }
23072 if (_v) {
23073 {
23074 void *ptr = 0;
23075 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23076 _v = 0;
23077 PyErr_Clear();
23078 } else {
23079 _v = (ptr != 0);
23080 }
23081 }
23082 if (_v) {
23083 return _wrap_DateTime___sub____SWIG_2(self,args);
23084 }
23085 }
23086 }
23087
23088 Py_INCREF(Py_NotImplemented);
23089 return Py_NotImplemented;
23090 }
23091
23092
23093 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj;
23095 wxDateTime *arg1 = (wxDateTime *) 0 ;
23096 wxDateTime *arg2 = (wxDateTime *) 0 ;
23097 bool result;
23098 PyObject * obj0 = 0 ;
23099 PyObject * obj1 = 0 ;
23100 char *kwnames[] = {
23101 (char *) "self",(char *) "other", NULL
23102 };
23103
23104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23106 if (SWIG_arg_fail(1)) SWIG_fail;
23107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23108 if (SWIG_arg_fail(2)) SWIG_fail;
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23112
23113 wxPyEndAllowThreads(__tstate);
23114 if (PyErr_Occurred()) SWIG_fail;
23115 }
23116 {
23117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23118 }
23119 return resultobj;
23120 fail:
23121 return NULL;
23122 }
23123
23124
23125 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23126 PyObject *resultobj;
23127 wxDateTime *arg1 = (wxDateTime *) 0 ;
23128 wxDateTime *arg2 = (wxDateTime *) 0 ;
23129 bool result;
23130 PyObject * obj0 = 0 ;
23131 PyObject * obj1 = 0 ;
23132 char *kwnames[] = {
23133 (char *) "self",(char *) "other", NULL
23134 };
23135
23136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23138 if (SWIG_arg_fail(1)) SWIG_fail;
23139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23140 if (SWIG_arg_fail(2)) SWIG_fail;
23141 {
23142 PyThreadState* __tstate = wxPyBeginAllowThreads();
23143 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23144
23145 wxPyEndAllowThreads(__tstate);
23146 if (PyErr_Occurred()) SWIG_fail;
23147 }
23148 {
23149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23150 }
23151 return resultobj;
23152 fail:
23153 return NULL;
23154 }
23155
23156
23157 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23158 PyObject *resultobj;
23159 wxDateTime *arg1 = (wxDateTime *) 0 ;
23160 wxDateTime *arg2 = (wxDateTime *) 0 ;
23161 bool result;
23162 PyObject * obj0 = 0 ;
23163 PyObject * obj1 = 0 ;
23164 char *kwnames[] = {
23165 (char *) "self",(char *) "other", NULL
23166 };
23167
23168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23170 if (SWIG_arg_fail(1)) SWIG_fail;
23171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23172 if (SWIG_arg_fail(2)) SWIG_fail;
23173 {
23174 PyThreadState* __tstate = wxPyBeginAllowThreads();
23175 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23176
23177 wxPyEndAllowThreads(__tstate);
23178 if (PyErr_Occurred()) SWIG_fail;
23179 }
23180 {
23181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23182 }
23183 return resultobj;
23184 fail:
23185 return NULL;
23186 }
23187
23188
23189 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23190 PyObject *resultobj;
23191 wxDateTime *arg1 = (wxDateTime *) 0 ;
23192 wxDateTime *arg2 = (wxDateTime *) 0 ;
23193 bool result;
23194 PyObject * obj0 = 0 ;
23195 PyObject * obj1 = 0 ;
23196 char *kwnames[] = {
23197 (char *) "self",(char *) "other", NULL
23198 };
23199
23200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(1)) SWIG_fail;
23203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23204 if (SWIG_arg_fail(2)) SWIG_fail;
23205 {
23206 PyThreadState* __tstate = wxPyBeginAllowThreads();
23207 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23208
23209 wxPyEndAllowThreads(__tstate);
23210 if (PyErr_Occurred()) SWIG_fail;
23211 }
23212 {
23213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23214 }
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj;
23223 wxDateTime *arg1 = (wxDateTime *) 0 ;
23224 wxDateTime *arg2 = (wxDateTime *) 0 ;
23225 bool result;
23226 PyObject * obj0 = 0 ;
23227 PyObject * obj1 = 0 ;
23228 char *kwnames[] = {
23229 (char *) "self",(char *) "other", NULL
23230 };
23231
23232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(1)) SWIG_fail;
23235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23236 if (SWIG_arg_fail(2)) SWIG_fail;
23237 {
23238 PyThreadState* __tstate = wxPyBeginAllowThreads();
23239 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23240
23241 wxPyEndAllowThreads(__tstate);
23242 if (PyErr_Occurred()) SWIG_fail;
23243 }
23244 {
23245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23246 }
23247 return resultobj;
23248 fail:
23249 return NULL;
23250 }
23251
23252
23253 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23254 PyObject *resultobj;
23255 wxDateTime *arg1 = (wxDateTime *) 0 ;
23256 wxDateTime *arg2 = (wxDateTime *) 0 ;
23257 bool result;
23258 PyObject * obj0 = 0 ;
23259 PyObject * obj1 = 0 ;
23260 char *kwnames[] = {
23261 (char *) "self",(char *) "other", NULL
23262 };
23263
23264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23266 if (SWIG_arg_fail(1)) SWIG_fail;
23267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23268 if (SWIG_arg_fail(2)) SWIG_fail;
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23272
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 {
23277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23278 }
23279 return resultobj;
23280 fail:
23281 return NULL;
23282 }
23283
23284
23285 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23286 PyObject *resultobj;
23287 wxDateTime *arg1 = (wxDateTime *) 0 ;
23288 wxString *arg2 = 0 ;
23289 int result;
23290 bool temp2 = false ;
23291 PyObject * obj0 = 0 ;
23292 PyObject * obj1 = 0 ;
23293 char *kwnames[] = {
23294 (char *) "self",(char *) "date", NULL
23295 };
23296
23297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23299 if (SWIG_arg_fail(1)) SWIG_fail;
23300 {
23301 arg2 = wxString_in_helper(obj1);
23302 if (arg2 == NULL) SWIG_fail;
23303 temp2 = true;
23304 }
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23308
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 {
23313 resultobj = SWIG_From_int((int)(result));
23314 }
23315 {
23316 if (temp2)
23317 delete arg2;
23318 }
23319 return resultobj;
23320 fail:
23321 {
23322 if (temp2)
23323 delete arg2;
23324 }
23325 return NULL;
23326 }
23327
23328
23329 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23330 PyObject *resultobj;
23331 wxDateTime *arg1 = (wxDateTime *) 0 ;
23332 wxString *arg2 = 0 ;
23333 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23334 wxString *arg3 = (wxString *) &arg3_defvalue ;
23335 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23336 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23337 int result;
23338 bool temp2 = false ;
23339 bool temp3 = false ;
23340 PyObject * obj0 = 0 ;
23341 PyObject * obj1 = 0 ;
23342 PyObject * obj2 = 0 ;
23343 PyObject * obj3 = 0 ;
23344 char *kwnames[] = {
23345 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23346 };
23347
23348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23350 if (SWIG_arg_fail(1)) SWIG_fail;
23351 {
23352 arg2 = wxString_in_helper(obj1);
23353 if (arg2 == NULL) SWIG_fail;
23354 temp2 = true;
23355 }
23356 if (obj2) {
23357 {
23358 arg3 = wxString_in_helper(obj2);
23359 if (arg3 == NULL) SWIG_fail;
23360 temp3 = true;
23361 }
23362 }
23363 if (obj3) {
23364 {
23365 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23366 if (SWIG_arg_fail(4)) SWIG_fail;
23367 if (arg4 == NULL) {
23368 SWIG_null_ref("wxDateTime");
23369 }
23370 if (SWIG_arg_fail(4)) SWIG_fail;
23371 }
23372 }
23373 {
23374 PyThreadState* __tstate = wxPyBeginAllowThreads();
23375 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23376
23377 wxPyEndAllowThreads(__tstate);
23378 if (PyErr_Occurred()) SWIG_fail;
23379 }
23380 {
23381 resultobj = SWIG_From_int((int)(result));
23382 }
23383 {
23384 if (temp2)
23385 delete arg2;
23386 }
23387 {
23388 if (temp3)
23389 delete arg3;
23390 }
23391 return resultobj;
23392 fail:
23393 {
23394 if (temp2)
23395 delete arg2;
23396 }
23397 {
23398 if (temp3)
23399 delete arg3;
23400 }
23401 return NULL;
23402 }
23403
23404
23405 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj;
23407 wxDateTime *arg1 = (wxDateTime *) 0 ;
23408 wxString *arg2 = 0 ;
23409 int result;
23410 bool temp2 = false ;
23411 PyObject * obj0 = 0 ;
23412 PyObject * obj1 = 0 ;
23413 char *kwnames[] = {
23414 (char *) "self",(char *) "datetime", NULL
23415 };
23416
23417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23419 if (SWIG_arg_fail(1)) SWIG_fail;
23420 {
23421 arg2 = wxString_in_helper(obj1);
23422 if (arg2 == NULL) SWIG_fail;
23423 temp2 = true;
23424 }
23425 {
23426 PyThreadState* __tstate = wxPyBeginAllowThreads();
23427 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23428
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = SWIG_From_int((int)(result));
23434 }
23435 {
23436 if (temp2)
23437 delete arg2;
23438 }
23439 return resultobj;
23440 fail:
23441 {
23442 if (temp2)
23443 delete arg2;
23444 }
23445 return NULL;
23446 }
23447
23448
23449 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj;
23451 wxDateTime *arg1 = (wxDateTime *) 0 ;
23452 wxString *arg2 = 0 ;
23453 int result;
23454 bool temp2 = false ;
23455 PyObject * obj0 = 0 ;
23456 PyObject * obj1 = 0 ;
23457 char *kwnames[] = {
23458 (char *) "self",(char *) "date", NULL
23459 };
23460
23461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23463 if (SWIG_arg_fail(1)) SWIG_fail;
23464 {
23465 arg2 = wxString_in_helper(obj1);
23466 if (arg2 == NULL) SWIG_fail;
23467 temp2 = true;
23468 }
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23472
23473 wxPyEndAllowThreads(__tstate);
23474 if (PyErr_Occurred()) SWIG_fail;
23475 }
23476 {
23477 resultobj = SWIG_From_int((int)(result));
23478 }
23479 {
23480 if (temp2)
23481 delete arg2;
23482 }
23483 return resultobj;
23484 fail:
23485 {
23486 if (temp2)
23487 delete arg2;
23488 }
23489 return NULL;
23490 }
23491
23492
23493 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23494 PyObject *resultobj;
23495 wxDateTime *arg1 = (wxDateTime *) 0 ;
23496 wxString *arg2 = 0 ;
23497 int result;
23498 bool temp2 = false ;
23499 PyObject * obj0 = 0 ;
23500 PyObject * obj1 = 0 ;
23501 char *kwnames[] = {
23502 (char *) "self",(char *) "time", NULL
23503 };
23504
23505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23507 if (SWIG_arg_fail(1)) SWIG_fail;
23508 {
23509 arg2 = wxString_in_helper(obj1);
23510 if (arg2 == NULL) SWIG_fail;
23511 temp2 = true;
23512 }
23513 {
23514 PyThreadState* __tstate = wxPyBeginAllowThreads();
23515 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23516
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 {
23521 resultobj = SWIG_From_int((int)(result));
23522 }
23523 {
23524 if (temp2)
23525 delete arg2;
23526 }
23527 return resultobj;
23528 fail:
23529 {
23530 if (temp2)
23531 delete arg2;
23532 }
23533 return NULL;
23534 }
23535
23536
23537 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23538 PyObject *resultobj;
23539 wxDateTime *arg1 = (wxDateTime *) 0 ;
23540 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23541 wxString *arg2 = (wxString *) &arg2_defvalue ;
23542 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23543 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23544 wxString result;
23545 bool temp2 = false ;
23546 bool temp3 = false ;
23547 PyObject * obj0 = 0 ;
23548 PyObject * obj1 = 0 ;
23549 PyObject * obj2 = 0 ;
23550 char *kwnames[] = {
23551 (char *) "self",(char *) "format",(char *) "tz", NULL
23552 };
23553
23554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23556 if (SWIG_arg_fail(1)) SWIG_fail;
23557 if (obj1) {
23558 {
23559 arg2 = wxString_in_helper(obj1);
23560 if (arg2 == NULL) SWIG_fail;
23561 temp2 = true;
23562 }
23563 }
23564 if (obj2) {
23565 {
23566 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23567 temp3 = true;
23568 }
23569 }
23570 {
23571 PyThreadState* __tstate = wxPyBeginAllowThreads();
23572 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23573
23574 wxPyEndAllowThreads(__tstate);
23575 if (PyErr_Occurred()) SWIG_fail;
23576 }
23577 {
23578 #if wxUSE_UNICODE
23579 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23580 #else
23581 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23582 #endif
23583 }
23584 {
23585 if (temp2)
23586 delete arg2;
23587 }
23588 {
23589 if (temp3) delete arg3;
23590 }
23591 return resultobj;
23592 fail:
23593 {
23594 if (temp2)
23595 delete arg2;
23596 }
23597 {
23598 if (temp3) delete arg3;
23599 }
23600 return NULL;
23601 }
23602
23603
23604 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23605 PyObject *resultobj;
23606 wxDateTime *arg1 = (wxDateTime *) 0 ;
23607 wxString result;
23608 PyObject * obj0 = 0 ;
23609 char *kwnames[] = {
23610 (char *) "self", NULL
23611 };
23612
23613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23615 if (SWIG_arg_fail(1)) SWIG_fail;
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = ((wxDateTime const *)arg1)->FormatDate();
23619
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 {
23624 #if wxUSE_UNICODE
23625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23626 #else
23627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23628 #endif
23629 }
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23637 PyObject *resultobj;
23638 wxDateTime *arg1 = (wxDateTime *) 0 ;
23639 wxString result;
23640 PyObject * obj0 = 0 ;
23641 char *kwnames[] = {
23642 (char *) "self", NULL
23643 };
23644
23645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23647 if (SWIG_arg_fail(1)) SWIG_fail;
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 result = ((wxDateTime const *)arg1)->FormatTime();
23651
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 {
23656 #if wxUSE_UNICODE
23657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23658 #else
23659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23660 #endif
23661 }
23662 return resultobj;
23663 fail:
23664 return NULL;
23665 }
23666
23667
23668 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23669 PyObject *resultobj;
23670 wxDateTime *arg1 = (wxDateTime *) 0 ;
23671 wxString result;
23672 PyObject * obj0 = 0 ;
23673 char *kwnames[] = {
23674 (char *) "self", NULL
23675 };
23676
23677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23679 if (SWIG_arg_fail(1)) SWIG_fail;
23680 {
23681 PyThreadState* __tstate = wxPyBeginAllowThreads();
23682 result = ((wxDateTime const *)arg1)->FormatISODate();
23683
23684 wxPyEndAllowThreads(__tstate);
23685 if (PyErr_Occurred()) SWIG_fail;
23686 }
23687 {
23688 #if wxUSE_UNICODE
23689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23690 #else
23691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23692 #endif
23693 }
23694 return resultobj;
23695 fail:
23696 return NULL;
23697 }
23698
23699
23700 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23701 PyObject *resultobj;
23702 wxDateTime *arg1 = (wxDateTime *) 0 ;
23703 wxString result;
23704 PyObject * obj0 = 0 ;
23705 char *kwnames[] = {
23706 (char *) "self", NULL
23707 };
23708
23709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23711 if (SWIG_arg_fail(1)) SWIG_fail;
23712 {
23713 PyThreadState* __tstate = wxPyBeginAllowThreads();
23714 result = ((wxDateTime const *)arg1)->FormatISOTime();
23715
23716 wxPyEndAllowThreads(__tstate);
23717 if (PyErr_Occurred()) SWIG_fail;
23718 }
23719 {
23720 #if wxUSE_UNICODE
23721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23722 #else
23723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23724 #endif
23725 }
23726 return resultobj;
23727 fail:
23728 return NULL;
23729 }
23730
23731
23732 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23733 PyObject *obj;
23734 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23735 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23736 Py_INCREF(obj);
23737 return Py_BuildValue((char *)"");
23738 }
23739 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj;
23741 long arg1 ;
23742 wxTimeSpan result;
23743 PyObject * obj0 = 0 ;
23744 char *kwnames[] = {
23745 (char *) "sec", NULL
23746 };
23747
23748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23749 {
23750 arg1 = (long)(SWIG_As_long(obj0));
23751 if (SWIG_arg_fail(1)) SWIG_fail;
23752 }
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 result = wxTimeSpan::Seconds(arg1);
23756
23757 wxPyEndAllowThreads(__tstate);
23758 if (PyErr_Occurred()) SWIG_fail;
23759 }
23760 {
23761 wxTimeSpan * resultptr;
23762 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23764 }
23765 return resultobj;
23766 fail:
23767 return NULL;
23768 }
23769
23770
23771 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23772 PyObject *resultobj;
23773 wxTimeSpan result;
23774 char *kwnames[] = {
23775 NULL
23776 };
23777
23778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = wxTimeSpan::Second();
23782
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 wxTimeSpan * resultptr;
23788 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23789 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23790 }
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj;
23799 long arg1 ;
23800 wxTimeSpan result;
23801 PyObject * obj0 = 0 ;
23802 char *kwnames[] = {
23803 (char *) "min", NULL
23804 };
23805
23806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23807 {
23808 arg1 = (long)(SWIG_As_long(obj0));
23809 if (SWIG_arg_fail(1)) SWIG_fail;
23810 }
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = wxTimeSpan::Minutes(arg1);
23814
23815 wxPyEndAllowThreads(__tstate);
23816 if (PyErr_Occurred()) SWIG_fail;
23817 }
23818 {
23819 wxTimeSpan * resultptr;
23820 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23821 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23822 }
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj;
23831 wxTimeSpan result;
23832 char *kwnames[] = {
23833 NULL
23834 };
23835
23836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = wxTimeSpan::Minute();
23840
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 {
23845 wxTimeSpan * resultptr;
23846 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23856 PyObject *resultobj;
23857 long arg1 ;
23858 wxTimeSpan result;
23859 PyObject * obj0 = 0 ;
23860 char *kwnames[] = {
23861 (char *) "hours", NULL
23862 };
23863
23864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23865 {
23866 arg1 = (long)(SWIG_As_long(obj0));
23867 if (SWIG_arg_fail(1)) SWIG_fail;
23868 }
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = wxTimeSpan::Hours(arg1);
23872
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 {
23877 wxTimeSpan * resultptr;
23878 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23879 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23880 }
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 wxTimeSpan result;
23890 char *kwnames[] = {
23891 NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = wxTimeSpan::Hour();
23898
23899 wxPyEndAllowThreads(__tstate);
23900 if (PyErr_Occurred()) SWIG_fail;
23901 }
23902 {
23903 wxTimeSpan * resultptr;
23904 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23905 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23906 }
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj;
23915 long arg1 ;
23916 wxTimeSpan result;
23917 PyObject * obj0 = 0 ;
23918 char *kwnames[] = {
23919 (char *) "days", NULL
23920 };
23921
23922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23923 {
23924 arg1 = (long)(SWIG_As_long(obj0));
23925 if (SWIG_arg_fail(1)) SWIG_fail;
23926 }
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 result = wxTimeSpan::Days(arg1);
23930
23931 wxPyEndAllowThreads(__tstate);
23932 if (PyErr_Occurred()) SWIG_fail;
23933 }
23934 {
23935 wxTimeSpan * resultptr;
23936 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23937 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23946 PyObject *resultobj;
23947 wxTimeSpan result;
23948 char *kwnames[] = {
23949 NULL
23950 };
23951
23952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = wxTimeSpan::Day();
23956
23957 wxPyEndAllowThreads(__tstate);
23958 if (PyErr_Occurred()) SWIG_fail;
23959 }
23960 {
23961 wxTimeSpan * resultptr;
23962 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23964 }
23965 return resultobj;
23966 fail:
23967 return NULL;
23968 }
23969
23970
23971 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23972 PyObject *resultobj;
23973 long arg1 ;
23974 wxTimeSpan result;
23975 PyObject * obj0 = 0 ;
23976 char *kwnames[] = {
23977 (char *) "days", NULL
23978 };
23979
23980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23981 {
23982 arg1 = (long)(SWIG_As_long(obj0));
23983 if (SWIG_arg_fail(1)) SWIG_fail;
23984 }
23985 {
23986 PyThreadState* __tstate = wxPyBeginAllowThreads();
23987 result = wxTimeSpan::Weeks(arg1);
23988
23989 wxPyEndAllowThreads(__tstate);
23990 if (PyErr_Occurred()) SWIG_fail;
23991 }
23992 {
23993 wxTimeSpan * resultptr;
23994 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23996 }
23997 return resultobj;
23998 fail:
23999 return NULL;
24000 }
24001
24002
24003 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24004 PyObject *resultobj;
24005 wxTimeSpan result;
24006 char *kwnames[] = {
24007 NULL
24008 };
24009
24010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = wxTimeSpan::Week();
24014
24015 wxPyEndAllowThreads(__tstate);
24016 if (PyErr_Occurred()) SWIG_fail;
24017 }
24018 {
24019 wxTimeSpan * resultptr;
24020 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24022 }
24023 return resultobj;
24024 fail:
24025 return NULL;
24026 }
24027
24028
24029 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24030 PyObject *resultobj;
24031 long arg1 = (long) 0 ;
24032 long arg2 = (long) 0 ;
24033 long arg3 = (long) 0 ;
24034 long arg4 = (long) 0 ;
24035 wxTimeSpan *result;
24036 PyObject * obj0 = 0 ;
24037 PyObject * obj1 = 0 ;
24038 PyObject * obj2 = 0 ;
24039 PyObject * obj3 = 0 ;
24040 char *kwnames[] = {
24041 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24042 };
24043
24044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24045 if (obj0) {
24046 {
24047 arg1 = (long)(SWIG_As_long(obj0));
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 }
24050 }
24051 if (obj1) {
24052 {
24053 arg2 = (long)(SWIG_As_long(obj1));
24054 if (SWIG_arg_fail(2)) SWIG_fail;
24055 }
24056 }
24057 if (obj2) {
24058 {
24059 arg3 = (long)(SWIG_As_long(obj2));
24060 if (SWIG_arg_fail(3)) SWIG_fail;
24061 }
24062 }
24063 if (obj3) {
24064 {
24065 arg4 = (long)(SWIG_As_long(obj3));
24066 if (SWIG_arg_fail(4)) SWIG_fail;
24067 }
24068 }
24069 {
24070 PyThreadState* __tstate = wxPyBeginAllowThreads();
24071 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24072
24073 wxPyEndAllowThreads(__tstate);
24074 if (PyErr_Occurred()) SWIG_fail;
24075 }
24076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24077 return resultobj;
24078 fail:
24079 return NULL;
24080 }
24081
24082
24083 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24084 PyObject *resultobj;
24085 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24086 PyObject * obj0 = 0 ;
24087 char *kwnames[] = {
24088 (char *) "self", NULL
24089 };
24090
24091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24093 if (SWIG_arg_fail(1)) SWIG_fail;
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 delete arg1;
24097
24098 wxPyEndAllowThreads(__tstate);
24099 if (PyErr_Occurred()) SWIG_fail;
24100 }
24101 Py_INCREF(Py_None); resultobj = Py_None;
24102 return resultobj;
24103 fail:
24104 return NULL;
24105 }
24106
24107
24108 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24109 PyObject *resultobj;
24110 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24111 wxTimeSpan *arg2 = 0 ;
24112 wxTimeSpan *result;
24113 PyObject * obj0 = 0 ;
24114 PyObject * obj1 = 0 ;
24115 char *kwnames[] = {
24116 (char *) "self",(char *) "diff", NULL
24117 };
24118
24119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24121 if (SWIG_arg_fail(1)) SWIG_fail;
24122 {
24123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24124 if (SWIG_arg_fail(2)) SWIG_fail;
24125 if (arg2 == NULL) {
24126 SWIG_null_ref("wxTimeSpan");
24127 }
24128 if (SWIG_arg_fail(2)) SWIG_fail;
24129 }
24130 {
24131 PyThreadState* __tstate = wxPyBeginAllowThreads();
24132 {
24133 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24134 result = (wxTimeSpan *) &_result_ref;
24135 }
24136
24137 wxPyEndAllowThreads(__tstate);
24138 if (PyErr_Occurred()) SWIG_fail;
24139 }
24140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24141 return resultobj;
24142 fail:
24143 return NULL;
24144 }
24145
24146
24147 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24148 PyObject *resultobj;
24149 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24150 wxTimeSpan *arg2 = 0 ;
24151 wxTimeSpan *result;
24152 PyObject * obj0 = 0 ;
24153 PyObject * obj1 = 0 ;
24154 char *kwnames[] = {
24155 (char *) "self",(char *) "diff", NULL
24156 };
24157
24158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24160 if (SWIG_arg_fail(1)) SWIG_fail;
24161 {
24162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24163 if (SWIG_arg_fail(2)) SWIG_fail;
24164 if (arg2 == NULL) {
24165 SWIG_null_ref("wxTimeSpan");
24166 }
24167 if (SWIG_arg_fail(2)) SWIG_fail;
24168 }
24169 {
24170 PyThreadState* __tstate = wxPyBeginAllowThreads();
24171 {
24172 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24173 result = (wxTimeSpan *) &_result_ref;
24174 }
24175
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj;
24188 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24189 int arg2 ;
24190 wxTimeSpan *result;
24191 PyObject * obj0 = 0 ;
24192 PyObject * obj1 = 0 ;
24193 char *kwnames[] = {
24194 (char *) "self",(char *) "n", NULL
24195 };
24196
24197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24199 if (SWIG_arg_fail(1)) SWIG_fail;
24200 {
24201 arg2 = (int)(SWIG_As_int(obj1));
24202 if (SWIG_arg_fail(2)) SWIG_fail;
24203 }
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 {
24207 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24208 result = (wxTimeSpan *) &_result_ref;
24209 }
24210
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24215 return resultobj;
24216 fail:
24217 return NULL;
24218 }
24219
24220
24221 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24222 PyObject *resultobj;
24223 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24224 wxTimeSpan *result;
24225 PyObject * obj0 = 0 ;
24226 char *kwnames[] = {
24227 (char *) "self", NULL
24228 };
24229
24230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24232 if (SWIG_arg_fail(1)) SWIG_fail;
24233 {
24234 PyThreadState* __tstate = wxPyBeginAllowThreads();
24235 {
24236 wxTimeSpan &_result_ref = (arg1)->Neg();
24237 result = (wxTimeSpan *) &_result_ref;
24238 }
24239
24240 wxPyEndAllowThreads(__tstate);
24241 if (PyErr_Occurred()) SWIG_fail;
24242 }
24243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24244 return resultobj;
24245 fail:
24246 return NULL;
24247 }
24248
24249
24250 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24251 PyObject *resultobj;
24252 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24253 wxTimeSpan result;
24254 PyObject * obj0 = 0 ;
24255 char *kwnames[] = {
24256 (char *) "self", NULL
24257 };
24258
24259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24261 if (SWIG_arg_fail(1)) SWIG_fail;
24262 {
24263 PyThreadState* __tstate = wxPyBeginAllowThreads();
24264 result = ((wxTimeSpan const *)arg1)->Abs();
24265
24266 wxPyEndAllowThreads(__tstate);
24267 if (PyErr_Occurred()) SWIG_fail;
24268 }
24269 {
24270 wxTimeSpan * resultptr;
24271 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24273 }
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24283 wxTimeSpan *arg2 = 0 ;
24284 wxTimeSpan *result;
24285 PyObject * obj0 = 0 ;
24286 PyObject * obj1 = 0 ;
24287 char *kwnames[] = {
24288 (char *) "self",(char *) "diff", NULL
24289 };
24290
24291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24293 if (SWIG_arg_fail(1)) SWIG_fail;
24294 {
24295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24296 if (SWIG_arg_fail(2)) SWIG_fail;
24297 if (arg2 == NULL) {
24298 SWIG_null_ref("wxTimeSpan");
24299 }
24300 if (SWIG_arg_fail(2)) SWIG_fail;
24301 }
24302 {
24303 PyThreadState* __tstate = wxPyBeginAllowThreads();
24304 {
24305 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24306 result = (wxTimeSpan *) &_result_ref;
24307 }
24308
24309 wxPyEndAllowThreads(__tstate);
24310 if (PyErr_Occurred()) SWIG_fail;
24311 }
24312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24320 PyObject *resultobj;
24321 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24322 wxTimeSpan *arg2 = 0 ;
24323 wxTimeSpan *result;
24324 PyObject * obj0 = 0 ;
24325 PyObject * obj1 = 0 ;
24326 char *kwnames[] = {
24327 (char *) "self",(char *) "diff", NULL
24328 };
24329
24330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24332 if (SWIG_arg_fail(1)) SWIG_fail;
24333 {
24334 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24335 if (SWIG_arg_fail(2)) SWIG_fail;
24336 if (arg2 == NULL) {
24337 SWIG_null_ref("wxTimeSpan");
24338 }
24339 if (SWIG_arg_fail(2)) SWIG_fail;
24340 }
24341 {
24342 PyThreadState* __tstate = wxPyBeginAllowThreads();
24343 {
24344 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24345 result = (wxTimeSpan *) &_result_ref;
24346 }
24347
24348 wxPyEndAllowThreads(__tstate);
24349 if (PyErr_Occurred()) SWIG_fail;
24350 }
24351 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj;
24360 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24361 int arg2 ;
24362 wxTimeSpan *result;
24363 PyObject * obj0 = 0 ;
24364 PyObject * obj1 = 0 ;
24365 char *kwnames[] = {
24366 (char *) "self",(char *) "n", NULL
24367 };
24368
24369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24371 if (SWIG_arg_fail(1)) SWIG_fail;
24372 {
24373 arg2 = (int)(SWIG_As_int(obj1));
24374 if (SWIG_arg_fail(2)) SWIG_fail;
24375 }
24376 {
24377 PyThreadState* __tstate = wxPyBeginAllowThreads();
24378 {
24379 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24380 result = (wxTimeSpan *) &_result_ref;
24381 }
24382
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24394 PyObject *resultobj;
24395 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24396 wxTimeSpan *result;
24397 PyObject * obj0 = 0 ;
24398 char *kwnames[] = {
24399 (char *) "self", NULL
24400 };
24401
24402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24404 if (SWIG_arg_fail(1)) SWIG_fail;
24405 {
24406 PyThreadState* __tstate = wxPyBeginAllowThreads();
24407 {
24408 wxTimeSpan &_result_ref = (arg1)->operator -();
24409 result = (wxTimeSpan *) &_result_ref;
24410 }
24411
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24416 return resultobj;
24417 fail:
24418 return NULL;
24419 }
24420
24421
24422 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24423 PyObject *resultobj;
24424 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24425 wxTimeSpan *arg2 = 0 ;
24426 wxTimeSpan result;
24427 PyObject * obj0 = 0 ;
24428 PyObject * obj1 = 0 ;
24429 char *kwnames[] = {
24430 (char *) "self",(char *) "other", NULL
24431 };
24432
24433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24435 if (SWIG_arg_fail(1)) SWIG_fail;
24436 {
24437 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24438 if (SWIG_arg_fail(2)) SWIG_fail;
24439 if (arg2 == NULL) {
24440 SWIG_null_ref("wxTimeSpan");
24441 }
24442 if (SWIG_arg_fail(2)) SWIG_fail;
24443 }
24444 {
24445 PyThreadState* __tstate = wxPyBeginAllowThreads();
24446 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24447
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 {
24452 wxTimeSpan * resultptr;
24453 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24455 }
24456 return resultobj;
24457 fail:
24458 return NULL;
24459 }
24460
24461
24462 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24463 PyObject *resultobj;
24464 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24465 wxTimeSpan *arg2 = 0 ;
24466 wxTimeSpan result;
24467 PyObject * obj0 = 0 ;
24468 PyObject * obj1 = 0 ;
24469 char *kwnames[] = {
24470 (char *) "self",(char *) "other", NULL
24471 };
24472
24473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24475 if (SWIG_arg_fail(1)) SWIG_fail;
24476 {
24477 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24478 if (SWIG_arg_fail(2)) SWIG_fail;
24479 if (arg2 == NULL) {
24480 SWIG_null_ref("wxTimeSpan");
24481 }
24482 if (SWIG_arg_fail(2)) SWIG_fail;
24483 }
24484 {
24485 PyThreadState* __tstate = wxPyBeginAllowThreads();
24486 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24487
24488 wxPyEndAllowThreads(__tstate);
24489 if (PyErr_Occurred()) SWIG_fail;
24490 }
24491 {
24492 wxTimeSpan * resultptr;
24493 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24495 }
24496 return resultobj;
24497 fail:
24498 return NULL;
24499 }
24500
24501
24502 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24503 PyObject *resultobj;
24504 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24505 int arg2 ;
24506 wxTimeSpan result;
24507 PyObject * obj0 = 0 ;
24508 PyObject * obj1 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "self",(char *) "n", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24515 if (SWIG_arg_fail(1)) SWIG_fail;
24516 {
24517 arg2 = (int)(SWIG_As_int(obj1));
24518 if (SWIG_arg_fail(2)) SWIG_fail;
24519 }
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = wxTimeSpan___mul__(arg1,arg2);
24523
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 {
24528 wxTimeSpan * resultptr;
24529 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24530 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj;
24540 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24541 int arg2 ;
24542 wxTimeSpan result;
24543 PyObject * obj0 = 0 ;
24544 PyObject * obj1 = 0 ;
24545 char *kwnames[] = {
24546 (char *) "self",(char *) "n", NULL
24547 };
24548
24549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24551 if (SWIG_arg_fail(1)) SWIG_fail;
24552 {
24553 arg2 = (int)(SWIG_As_int(obj1));
24554 if (SWIG_arg_fail(2)) SWIG_fail;
24555 }
24556 {
24557 PyThreadState* __tstate = wxPyBeginAllowThreads();
24558 result = wxTimeSpan___rmul__(arg1,arg2);
24559
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 {
24564 wxTimeSpan * resultptr;
24565 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24566 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24567 }
24568 return resultobj;
24569 fail:
24570 return NULL;
24571 }
24572
24573
24574 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24575 PyObject *resultobj;
24576 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24577 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24578 bool result;
24579 PyObject * obj0 = 0 ;
24580 PyObject * obj1 = 0 ;
24581 char *kwnames[] = {
24582 (char *) "self",(char *) "other", NULL
24583 };
24584
24585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24589 if (SWIG_arg_fail(2)) SWIG_fail;
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24609 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24610 bool result;
24611 PyObject * obj0 = 0 ;
24612 PyObject * obj1 = 0 ;
24613 char *kwnames[] = {
24614 (char *) "self",(char *) "other", NULL
24615 };
24616
24617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24619 if (SWIG_arg_fail(1)) SWIG_fail;
24620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24621 if (SWIG_arg_fail(2)) SWIG_fail;
24622 {
24623 PyThreadState* __tstate = wxPyBeginAllowThreads();
24624 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24625
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24639 PyObject *resultobj;
24640 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24641 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24642 bool result;
24643 PyObject * obj0 = 0 ;
24644 PyObject * obj1 = 0 ;
24645 char *kwnames[] = {
24646 (char *) "self",(char *) "other", NULL
24647 };
24648
24649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24651 if (SWIG_arg_fail(1)) SWIG_fail;
24652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24653 if (SWIG_arg_fail(2)) SWIG_fail;
24654 {
24655 PyThreadState* __tstate = wxPyBeginAllowThreads();
24656 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24657
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 {
24662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24663 }
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24671 PyObject *resultobj;
24672 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24673 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24674 bool result;
24675 PyObject * obj0 = 0 ;
24676 PyObject * obj1 = 0 ;
24677 char *kwnames[] = {
24678 (char *) "self",(char *) "other", NULL
24679 };
24680
24681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(1)) SWIG_fail;
24684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24685 if (SWIG_arg_fail(2)) SWIG_fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 {
24694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24695 }
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24703 PyObject *resultobj;
24704 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24705 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24706 bool result;
24707 PyObject * obj0 = 0 ;
24708 PyObject * obj1 = 0 ;
24709 char *kwnames[] = {
24710 (char *) "self",(char *) "other", NULL
24711 };
24712
24713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24715 if (SWIG_arg_fail(1)) SWIG_fail;
24716 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24717 if (SWIG_arg_fail(2)) SWIG_fail;
24718 {
24719 PyThreadState* __tstate = wxPyBeginAllowThreads();
24720 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24721
24722 wxPyEndAllowThreads(__tstate);
24723 if (PyErr_Occurred()) SWIG_fail;
24724 }
24725 {
24726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24727 }
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj;
24736 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24737 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24738 bool result;
24739 PyObject * obj0 = 0 ;
24740 PyObject * obj1 = 0 ;
24741 char *kwnames[] = {
24742 (char *) "self",(char *) "other", NULL
24743 };
24744
24745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(1)) SWIG_fail;
24748 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24749 if (SWIG_arg_fail(2)) SWIG_fail;
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24753
24754 wxPyEndAllowThreads(__tstate);
24755 if (PyErr_Occurred()) SWIG_fail;
24756 }
24757 {
24758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24759 }
24760 return resultobj;
24761 fail:
24762 return NULL;
24763 }
24764
24765
24766 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24767 PyObject *resultobj;
24768 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24769 bool result;
24770 PyObject * obj0 = 0 ;
24771 char *kwnames[] = {
24772 (char *) "self", NULL
24773 };
24774
24775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24777 if (SWIG_arg_fail(1)) SWIG_fail;
24778 {
24779 PyThreadState* __tstate = wxPyBeginAllowThreads();
24780 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24781
24782 wxPyEndAllowThreads(__tstate);
24783 if (PyErr_Occurred()) SWIG_fail;
24784 }
24785 {
24786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24787 }
24788 return resultobj;
24789 fail:
24790 return NULL;
24791 }
24792
24793
24794 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24795 PyObject *resultobj;
24796 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24797 bool result;
24798 PyObject * obj0 = 0 ;
24799 char *kwnames[] = {
24800 (char *) "self", NULL
24801 };
24802
24803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24805 if (SWIG_arg_fail(1)) SWIG_fail;
24806 {
24807 PyThreadState* __tstate = wxPyBeginAllowThreads();
24808 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24809
24810 wxPyEndAllowThreads(__tstate);
24811 if (PyErr_Occurred()) SWIG_fail;
24812 }
24813 {
24814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24815 }
24816 return resultobj;
24817 fail:
24818 return NULL;
24819 }
24820
24821
24822 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24823 PyObject *resultobj;
24824 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24825 bool result;
24826 PyObject * obj0 = 0 ;
24827 char *kwnames[] = {
24828 (char *) "self", NULL
24829 };
24830
24831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) 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 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24837
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 {
24842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24843 }
24844 return resultobj;
24845 fail:
24846 return NULL;
24847 }
24848
24849
24850 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24851 PyObject *resultobj;
24852 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24853 wxTimeSpan *arg2 = 0 ;
24854 bool result;
24855 PyObject * obj0 = 0 ;
24856 PyObject * obj1 = 0 ;
24857 char *kwnames[] = {
24858 (char *) "self",(char *) "ts", NULL
24859 };
24860
24861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24866 if (SWIG_arg_fail(2)) SWIG_fail;
24867 if (arg2 == NULL) {
24868 SWIG_null_ref("wxTimeSpan");
24869 }
24870 if (SWIG_arg_fail(2)) SWIG_fail;
24871 }
24872 {
24873 PyThreadState* __tstate = wxPyBeginAllowThreads();
24874 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24875
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 {
24880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24881 }
24882 return resultobj;
24883 fail:
24884 return NULL;
24885 }
24886
24887
24888 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24889 PyObject *resultobj;
24890 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24891 wxTimeSpan *arg2 = 0 ;
24892 bool result;
24893 PyObject * obj0 = 0 ;
24894 PyObject * obj1 = 0 ;
24895 char *kwnames[] = {
24896 (char *) "self",(char *) "ts", NULL
24897 };
24898
24899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24901 if (SWIG_arg_fail(1)) SWIG_fail;
24902 {
24903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24904 if (SWIG_arg_fail(2)) SWIG_fail;
24905 if (arg2 == NULL) {
24906 SWIG_null_ref("wxTimeSpan");
24907 }
24908 if (SWIG_arg_fail(2)) SWIG_fail;
24909 }
24910 {
24911 PyThreadState* __tstate = wxPyBeginAllowThreads();
24912 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24913
24914 wxPyEndAllowThreads(__tstate);
24915 if (PyErr_Occurred()) SWIG_fail;
24916 }
24917 {
24918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24919 }
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24927 PyObject *resultobj;
24928 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24929 wxTimeSpan *arg2 = 0 ;
24930 bool result;
24931 PyObject * obj0 = 0 ;
24932 PyObject * obj1 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self",(char *) "t", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 {
24941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24942 if (SWIG_arg_fail(2)) SWIG_fail;
24943 if (arg2 == NULL) {
24944 SWIG_null_ref("wxTimeSpan");
24945 }
24946 if (SWIG_arg_fail(2)) SWIG_fail;
24947 }
24948 {
24949 PyThreadState* __tstate = wxPyBeginAllowThreads();
24950 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24951
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj;
24966 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24967 int result;
24968 PyObject * obj0 = 0 ;
24969 char *kwnames[] = {
24970 (char *) "self", NULL
24971 };
24972
24973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24975 if (SWIG_arg_fail(1)) SWIG_fail;
24976 {
24977 PyThreadState* __tstate = wxPyBeginAllowThreads();
24978 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24979
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 {
24984 resultobj = SWIG_From_int((int)(result));
24985 }
24986 return resultobj;
24987 fail:
24988 return NULL;
24989 }
24990
24991
24992 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24993 PyObject *resultobj;
24994 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24995 int result;
24996 PyObject * obj0 = 0 ;
24997 char *kwnames[] = {
24998 (char *) "self", NULL
24999 };
25000
25001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25003 if (SWIG_arg_fail(1)) SWIG_fail;
25004 {
25005 PyThreadState* __tstate = wxPyBeginAllowThreads();
25006 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25007
25008 wxPyEndAllowThreads(__tstate);
25009 if (PyErr_Occurred()) SWIG_fail;
25010 }
25011 {
25012 resultobj = SWIG_From_int((int)(result));
25013 }
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25021 PyObject *resultobj;
25022 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25023 int result;
25024 PyObject * obj0 = 0 ;
25025 char *kwnames[] = {
25026 (char *) "self", NULL
25027 };
25028
25029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25031 if (SWIG_arg_fail(1)) SWIG_fail;
25032 {
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25035
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 resultobj = SWIG_From_int((int)(result));
25041 }
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25049 PyObject *resultobj;
25050 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25051 int result;
25052 PyObject * obj0 = 0 ;
25053 char *kwnames[] = {
25054 (char *) "self", NULL
25055 };
25056
25057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25059 if (SWIG_arg_fail(1)) SWIG_fail;
25060 {
25061 PyThreadState* __tstate = wxPyBeginAllowThreads();
25062 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25063
25064 wxPyEndAllowThreads(__tstate);
25065 if (PyErr_Occurred()) SWIG_fail;
25066 }
25067 {
25068 resultobj = SWIG_From_int((int)(result));
25069 }
25070 return resultobj;
25071 fail:
25072 return NULL;
25073 }
25074
25075
25076 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25077 PyObject *resultobj;
25078 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25079 wxLongLong result;
25080 PyObject * obj0 = 0 ;
25081 char *kwnames[] = {
25082 (char *) "self", NULL
25083 };
25084
25085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25087 if (SWIG_arg_fail(1)) SWIG_fail;
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25091
25092 wxPyEndAllowThreads(__tstate);
25093 if (PyErr_Occurred()) SWIG_fail;
25094 }
25095 {
25096 PyObject *hi, *lo, *shifter, *shifted;
25097 hi = PyLong_FromLong( (&result)->GetHi() );
25098 lo = PyLong_FromLong( (&result)->GetLo() );
25099 shifter = PyLong_FromLong(32);
25100 shifted = PyNumber_Lshift(hi, shifter);
25101 resultobj = PyNumber_Or(shifted, lo);
25102 Py_DECREF(hi);
25103 Py_DECREF(lo);
25104 Py_DECREF(shifter);
25105 Py_DECREF(shifted);
25106 }
25107 return resultobj;
25108 fail:
25109 return NULL;
25110 }
25111
25112
25113 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25114 PyObject *resultobj;
25115 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25116 wxLongLong result;
25117 PyObject * obj0 = 0 ;
25118 char *kwnames[] = {
25119 (char *) "self", NULL
25120 };
25121
25122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25124 if (SWIG_arg_fail(1)) SWIG_fail;
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25128
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 {
25133 PyObject *hi, *lo, *shifter, *shifted;
25134 hi = PyLong_FromLong( (&result)->GetHi() );
25135 lo = PyLong_FromLong( (&result)->GetLo() );
25136 shifter = PyLong_FromLong(32);
25137 shifted = PyNumber_Lshift(hi, shifter);
25138 resultobj = PyNumber_Or(shifted, lo);
25139 Py_DECREF(hi);
25140 Py_DECREF(lo);
25141 Py_DECREF(shifter);
25142 Py_DECREF(shifted);
25143 }
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25151 PyObject *resultobj;
25152 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25153 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25154 wxString *arg2 = (wxString *) &arg2_defvalue ;
25155 wxString result;
25156 bool temp2 = false ;
25157 PyObject * obj0 = 0 ;
25158 PyObject * obj1 = 0 ;
25159 char *kwnames[] = {
25160 (char *) "self",(char *) "format", NULL
25161 };
25162
25163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25165 if (SWIG_arg_fail(1)) SWIG_fail;
25166 if (obj1) {
25167 {
25168 arg2 = wxString_in_helper(obj1);
25169 if (arg2 == NULL) SWIG_fail;
25170 temp2 = true;
25171 }
25172 }
25173 {
25174 PyThreadState* __tstate = wxPyBeginAllowThreads();
25175 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25176
25177 wxPyEndAllowThreads(__tstate);
25178 if (PyErr_Occurred()) SWIG_fail;
25179 }
25180 {
25181 #if wxUSE_UNICODE
25182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25183 #else
25184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25185 #endif
25186 }
25187 {
25188 if (temp2)
25189 delete arg2;
25190 }
25191 return resultobj;
25192 fail:
25193 {
25194 if (temp2)
25195 delete arg2;
25196 }
25197 return NULL;
25198 }
25199
25200
25201 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25202 PyObject *obj;
25203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25204 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25205 Py_INCREF(obj);
25206 return Py_BuildValue((char *)"");
25207 }
25208 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25209 PyObject *resultobj;
25210 int arg1 = (int) 0 ;
25211 int arg2 = (int) 0 ;
25212 int arg3 = (int) 0 ;
25213 int arg4 = (int) 0 ;
25214 wxDateSpan *result;
25215 PyObject * obj0 = 0 ;
25216 PyObject * obj1 = 0 ;
25217 PyObject * obj2 = 0 ;
25218 PyObject * obj3 = 0 ;
25219 char *kwnames[] = {
25220 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25221 };
25222
25223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25224 if (obj0) {
25225 {
25226 arg1 = (int)(SWIG_As_int(obj0));
25227 if (SWIG_arg_fail(1)) SWIG_fail;
25228 }
25229 }
25230 if (obj1) {
25231 {
25232 arg2 = (int)(SWIG_As_int(obj1));
25233 if (SWIG_arg_fail(2)) SWIG_fail;
25234 }
25235 }
25236 if (obj2) {
25237 {
25238 arg3 = (int)(SWIG_As_int(obj2));
25239 if (SWIG_arg_fail(3)) SWIG_fail;
25240 }
25241 }
25242 if (obj3) {
25243 {
25244 arg4 = (int)(SWIG_As_int(obj3));
25245 if (SWIG_arg_fail(4)) SWIG_fail;
25246 }
25247 }
25248 {
25249 PyThreadState* __tstate = wxPyBeginAllowThreads();
25250 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25251
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25263 PyObject *resultobj;
25264 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25265 PyObject * obj0 = 0 ;
25266 char *kwnames[] = {
25267 (char *) "self", NULL
25268 };
25269
25270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25272 if (SWIG_arg_fail(1)) SWIG_fail;
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 delete arg1;
25276
25277 wxPyEndAllowThreads(__tstate);
25278 if (PyErr_Occurred()) SWIG_fail;
25279 }
25280 Py_INCREF(Py_None); resultobj = Py_None;
25281 return resultobj;
25282 fail:
25283 return NULL;
25284 }
25285
25286
25287 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25288 PyObject *resultobj;
25289 int arg1 ;
25290 wxDateSpan result;
25291 PyObject * obj0 = 0 ;
25292 char *kwnames[] = {
25293 (char *) "days", NULL
25294 };
25295
25296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25297 {
25298 arg1 = (int)(SWIG_As_int(obj0));
25299 if (SWIG_arg_fail(1)) SWIG_fail;
25300 }
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 result = wxDateSpan::Days(arg1);
25304
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 {
25309 wxDateSpan * resultptr;
25310 resultptr = new wxDateSpan((wxDateSpan &)(result));
25311 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25312 }
25313 return resultobj;
25314 fail:
25315 return NULL;
25316 }
25317
25318
25319 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25320 PyObject *resultobj;
25321 wxDateSpan result;
25322 char *kwnames[] = {
25323 NULL
25324 };
25325
25326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25327 {
25328 PyThreadState* __tstate = wxPyBeginAllowThreads();
25329 result = wxDateSpan::Day();
25330
25331 wxPyEndAllowThreads(__tstate);
25332 if (PyErr_Occurred()) SWIG_fail;
25333 }
25334 {
25335 wxDateSpan * resultptr;
25336 resultptr = new wxDateSpan((wxDateSpan &)(result));
25337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25338 }
25339 return resultobj;
25340 fail:
25341 return NULL;
25342 }
25343
25344
25345 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25346 PyObject *resultobj;
25347 int arg1 ;
25348 wxDateSpan result;
25349 PyObject * obj0 = 0 ;
25350 char *kwnames[] = {
25351 (char *) "weeks", NULL
25352 };
25353
25354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25355 {
25356 arg1 = (int)(SWIG_As_int(obj0));
25357 if (SWIG_arg_fail(1)) SWIG_fail;
25358 }
25359 {
25360 PyThreadState* __tstate = wxPyBeginAllowThreads();
25361 result = wxDateSpan::Weeks(arg1);
25362
25363 wxPyEndAllowThreads(__tstate);
25364 if (PyErr_Occurred()) SWIG_fail;
25365 }
25366 {
25367 wxDateSpan * resultptr;
25368 resultptr = new wxDateSpan((wxDateSpan &)(result));
25369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25370 }
25371 return resultobj;
25372 fail:
25373 return NULL;
25374 }
25375
25376
25377 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25378 PyObject *resultobj;
25379 wxDateSpan result;
25380 char *kwnames[] = {
25381 NULL
25382 };
25383
25384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25385 {
25386 PyThreadState* __tstate = wxPyBeginAllowThreads();
25387 result = wxDateSpan::Week();
25388
25389 wxPyEndAllowThreads(__tstate);
25390 if (PyErr_Occurred()) SWIG_fail;
25391 }
25392 {
25393 wxDateSpan * resultptr;
25394 resultptr = new wxDateSpan((wxDateSpan &)(result));
25395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25396 }
25397 return resultobj;
25398 fail:
25399 return NULL;
25400 }
25401
25402
25403 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25404 PyObject *resultobj;
25405 int arg1 ;
25406 wxDateSpan result;
25407 PyObject * obj0 = 0 ;
25408 char *kwnames[] = {
25409 (char *) "mon", NULL
25410 };
25411
25412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25413 {
25414 arg1 = (int)(SWIG_As_int(obj0));
25415 if (SWIG_arg_fail(1)) SWIG_fail;
25416 }
25417 {
25418 PyThreadState* __tstate = wxPyBeginAllowThreads();
25419 result = wxDateSpan::Months(arg1);
25420
25421 wxPyEndAllowThreads(__tstate);
25422 if (PyErr_Occurred()) SWIG_fail;
25423 }
25424 {
25425 wxDateSpan * resultptr;
25426 resultptr = new wxDateSpan((wxDateSpan &)(result));
25427 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25428 }
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj;
25437 wxDateSpan result;
25438 char *kwnames[] = {
25439 NULL
25440 };
25441
25442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25443 {
25444 PyThreadState* __tstate = wxPyBeginAllowThreads();
25445 result = wxDateSpan::Month();
25446
25447 wxPyEndAllowThreads(__tstate);
25448 if (PyErr_Occurred()) SWIG_fail;
25449 }
25450 {
25451 wxDateSpan * resultptr;
25452 resultptr = new wxDateSpan((wxDateSpan &)(result));
25453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25454 }
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25462 PyObject *resultobj;
25463 int arg1 ;
25464 wxDateSpan result;
25465 PyObject * obj0 = 0 ;
25466 char *kwnames[] = {
25467 (char *) "years", NULL
25468 };
25469
25470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25471 {
25472 arg1 = (int)(SWIG_As_int(obj0));
25473 if (SWIG_arg_fail(1)) SWIG_fail;
25474 }
25475 {
25476 PyThreadState* __tstate = wxPyBeginAllowThreads();
25477 result = wxDateSpan::Years(arg1);
25478
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 {
25483 wxDateSpan * resultptr;
25484 resultptr = new wxDateSpan((wxDateSpan &)(result));
25485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25486 }
25487 return resultobj;
25488 fail:
25489 return NULL;
25490 }
25491
25492
25493 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25494 PyObject *resultobj;
25495 wxDateSpan result;
25496 char *kwnames[] = {
25497 NULL
25498 };
25499
25500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25501 {
25502 PyThreadState* __tstate = wxPyBeginAllowThreads();
25503 result = wxDateSpan::Year();
25504
25505 wxPyEndAllowThreads(__tstate);
25506 if (PyErr_Occurred()) SWIG_fail;
25507 }
25508 {
25509 wxDateSpan * resultptr;
25510 resultptr = new wxDateSpan((wxDateSpan &)(result));
25511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25512 }
25513 return resultobj;
25514 fail:
25515 return NULL;
25516 }
25517
25518
25519 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25520 PyObject *resultobj;
25521 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25522 int arg2 ;
25523 wxDateSpan *result;
25524 PyObject * obj0 = 0 ;
25525 PyObject * obj1 = 0 ;
25526 char *kwnames[] = {
25527 (char *) "self",(char *) "n", NULL
25528 };
25529
25530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25532 if (SWIG_arg_fail(1)) SWIG_fail;
25533 {
25534 arg2 = (int)(SWIG_As_int(obj1));
25535 if (SWIG_arg_fail(2)) SWIG_fail;
25536 }
25537 {
25538 PyThreadState* __tstate = wxPyBeginAllowThreads();
25539 {
25540 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25541 result = (wxDateSpan *) &_result_ref;
25542 }
25543
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25548 return resultobj;
25549 fail:
25550 return NULL;
25551 }
25552
25553
25554 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj;
25556 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25557 int arg2 ;
25558 wxDateSpan *result;
25559 PyObject * obj0 = 0 ;
25560 PyObject * obj1 = 0 ;
25561 char *kwnames[] = {
25562 (char *) "self",(char *) "n", NULL
25563 };
25564
25565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25567 if (SWIG_arg_fail(1)) SWIG_fail;
25568 {
25569 arg2 = (int)(SWIG_As_int(obj1));
25570 if (SWIG_arg_fail(2)) SWIG_fail;
25571 }
25572 {
25573 PyThreadState* __tstate = wxPyBeginAllowThreads();
25574 {
25575 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25576 result = (wxDateSpan *) &_result_ref;
25577 }
25578
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj;
25591 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25592 int arg2 ;
25593 wxDateSpan *result;
25594 PyObject * obj0 = 0 ;
25595 PyObject * obj1 = 0 ;
25596 char *kwnames[] = {
25597 (char *) "self",(char *) "n", NULL
25598 };
25599
25600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25602 if (SWIG_arg_fail(1)) SWIG_fail;
25603 {
25604 arg2 = (int)(SWIG_As_int(obj1));
25605 if (SWIG_arg_fail(2)) SWIG_fail;
25606 }
25607 {
25608 PyThreadState* __tstate = wxPyBeginAllowThreads();
25609 {
25610 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25611 result = (wxDateSpan *) &_result_ref;
25612 }
25613
25614 wxPyEndAllowThreads(__tstate);
25615 if (PyErr_Occurred()) SWIG_fail;
25616 }
25617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25625 PyObject *resultobj;
25626 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25627 int arg2 ;
25628 wxDateSpan *result;
25629 PyObject * obj0 = 0 ;
25630 PyObject * obj1 = 0 ;
25631 char *kwnames[] = {
25632 (char *) "self",(char *) "n", NULL
25633 };
25634
25635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25637 if (SWIG_arg_fail(1)) SWIG_fail;
25638 {
25639 arg2 = (int)(SWIG_As_int(obj1));
25640 if (SWIG_arg_fail(2)) SWIG_fail;
25641 }
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 {
25645 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25646 result = (wxDateSpan *) &_result_ref;
25647 }
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj;
25661 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25662 int result;
25663 PyObject * obj0 = 0 ;
25664 char *kwnames[] = {
25665 (char *) "self", NULL
25666 };
25667
25668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25670 if (SWIG_arg_fail(1)) SWIG_fail;
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (int)((wxDateSpan const *)arg1)->GetYears();
25674
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 {
25679 resultobj = SWIG_From_int((int)(result));
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25690 int result;
25691 PyObject * obj0 = 0 ;
25692 char *kwnames[] = {
25693 (char *) "self", NULL
25694 };
25695
25696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25698 if (SWIG_arg_fail(1)) SWIG_fail;
25699 {
25700 PyThreadState* __tstate = wxPyBeginAllowThreads();
25701 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25702
25703 wxPyEndAllowThreads(__tstate);
25704 if (PyErr_Occurred()) SWIG_fail;
25705 }
25706 {
25707 resultobj = SWIG_From_int((int)(result));
25708 }
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25716 PyObject *resultobj;
25717 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25718 int result;
25719 PyObject * obj0 = 0 ;
25720 char *kwnames[] = {
25721 (char *) "self", NULL
25722 };
25723
25724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25726 if (SWIG_arg_fail(1)) SWIG_fail;
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25730
25731 wxPyEndAllowThreads(__tstate);
25732 if (PyErr_Occurred()) SWIG_fail;
25733 }
25734 {
25735 resultobj = SWIG_From_int((int)(result));
25736 }
25737 return resultobj;
25738 fail:
25739 return NULL;
25740 }
25741
25742
25743 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25744 PyObject *resultobj;
25745 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25746 int result;
25747 PyObject * obj0 = 0 ;
25748 char *kwnames[] = {
25749 (char *) "self", NULL
25750 };
25751
25752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25754 if (SWIG_arg_fail(1)) SWIG_fail;
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = (int)((wxDateSpan const *)arg1)->GetDays();
25758
25759 wxPyEndAllowThreads(__tstate);
25760 if (PyErr_Occurred()) SWIG_fail;
25761 }
25762 {
25763 resultobj = SWIG_From_int((int)(result));
25764 }
25765 return resultobj;
25766 fail:
25767 return NULL;
25768 }
25769
25770
25771 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25772 PyObject *resultobj;
25773 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25774 int result;
25775 PyObject * obj0 = 0 ;
25776 char *kwnames[] = {
25777 (char *) "self", NULL
25778 };
25779
25780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25782 if (SWIG_arg_fail(1)) SWIG_fail;
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25786
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 {
25791 resultobj = SWIG_From_int((int)(result));
25792 }
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25800 PyObject *resultobj;
25801 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25802 wxDateSpan *arg2 = 0 ;
25803 wxDateSpan *result;
25804 PyObject * obj0 = 0 ;
25805 PyObject * obj1 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self",(char *) "other", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25815 if (SWIG_arg_fail(2)) SWIG_fail;
25816 if (arg2 == NULL) {
25817 SWIG_null_ref("wxDateSpan");
25818 }
25819 if (SWIG_arg_fail(2)) SWIG_fail;
25820 }
25821 {
25822 PyThreadState* __tstate = wxPyBeginAllowThreads();
25823 {
25824 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25825 result = (wxDateSpan *) &_result_ref;
25826 }
25827
25828 wxPyEndAllowThreads(__tstate);
25829 if (PyErr_Occurred()) SWIG_fail;
25830 }
25831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25839 PyObject *resultobj;
25840 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25841 wxDateSpan *arg2 = 0 ;
25842 wxDateSpan *result;
25843 PyObject * obj0 = 0 ;
25844 PyObject * obj1 = 0 ;
25845 char *kwnames[] = {
25846 (char *) "self",(char *) "other", NULL
25847 };
25848
25849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25851 if (SWIG_arg_fail(1)) SWIG_fail;
25852 {
25853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25854 if (SWIG_arg_fail(2)) SWIG_fail;
25855 if (arg2 == NULL) {
25856 SWIG_null_ref("wxDateSpan");
25857 }
25858 if (SWIG_arg_fail(2)) SWIG_fail;
25859 }
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 {
25863 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25864 result = (wxDateSpan *) &_result_ref;
25865 }
25866
25867 wxPyEndAllowThreads(__tstate);
25868 if (PyErr_Occurred()) SWIG_fail;
25869 }
25870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25878 PyObject *resultobj;
25879 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25880 wxDateSpan *result;
25881 PyObject * obj0 = 0 ;
25882 char *kwnames[] = {
25883 (char *) "self", NULL
25884 };
25885
25886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25888 if (SWIG_arg_fail(1)) SWIG_fail;
25889 {
25890 PyThreadState* __tstate = wxPyBeginAllowThreads();
25891 {
25892 wxDateSpan &_result_ref = (arg1)->Neg();
25893 result = (wxDateSpan *) &_result_ref;
25894 }
25895
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25900 return resultobj;
25901 fail:
25902 return NULL;
25903 }
25904
25905
25906 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25907 PyObject *resultobj;
25908 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25909 int arg2 ;
25910 wxDateSpan *result;
25911 PyObject * obj0 = 0 ;
25912 PyObject * obj1 = 0 ;
25913 char *kwnames[] = {
25914 (char *) "self",(char *) "factor", NULL
25915 };
25916
25917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25919 if (SWIG_arg_fail(1)) SWIG_fail;
25920 {
25921 arg2 = (int)(SWIG_As_int(obj1));
25922 if (SWIG_arg_fail(2)) SWIG_fail;
25923 }
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 {
25927 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25928 result = (wxDateSpan *) &_result_ref;
25929 }
25930
25931 wxPyEndAllowThreads(__tstate);
25932 if (PyErr_Occurred()) SWIG_fail;
25933 }
25934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25935 return resultobj;
25936 fail:
25937 return NULL;
25938 }
25939
25940
25941 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25942 PyObject *resultobj;
25943 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25944 wxDateSpan *arg2 = 0 ;
25945 wxDateSpan *result;
25946 PyObject * obj0 = 0 ;
25947 PyObject * obj1 = 0 ;
25948 char *kwnames[] = {
25949 (char *) "self",(char *) "other", NULL
25950 };
25951
25952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25954 if (SWIG_arg_fail(1)) SWIG_fail;
25955 {
25956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25957 if (SWIG_arg_fail(2)) SWIG_fail;
25958 if (arg2 == NULL) {
25959 SWIG_null_ref("wxDateSpan");
25960 }
25961 if (SWIG_arg_fail(2)) SWIG_fail;
25962 }
25963 {
25964 PyThreadState* __tstate = wxPyBeginAllowThreads();
25965 {
25966 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25967 result = (wxDateSpan *) &_result_ref;
25968 }
25969
25970 wxPyEndAllowThreads(__tstate);
25971 if (PyErr_Occurred()) SWIG_fail;
25972 }
25973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25974 return resultobj;
25975 fail:
25976 return NULL;
25977 }
25978
25979
25980 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25981 PyObject *resultobj;
25982 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25983 wxDateSpan *arg2 = 0 ;
25984 wxDateSpan *result;
25985 PyObject * obj0 = 0 ;
25986 PyObject * obj1 = 0 ;
25987 char *kwnames[] = {
25988 (char *) "self",(char *) "other", NULL
25989 };
25990
25991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25993 if (SWIG_arg_fail(1)) SWIG_fail;
25994 {
25995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25996 if (SWIG_arg_fail(2)) SWIG_fail;
25997 if (arg2 == NULL) {
25998 SWIG_null_ref("wxDateSpan");
25999 }
26000 if (SWIG_arg_fail(2)) SWIG_fail;
26001 }
26002 {
26003 PyThreadState* __tstate = wxPyBeginAllowThreads();
26004 {
26005 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26006 result = (wxDateSpan *) &_result_ref;
26007 }
26008
26009 wxPyEndAllowThreads(__tstate);
26010 if (PyErr_Occurred()) SWIG_fail;
26011 }
26012 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26013 return resultobj;
26014 fail:
26015 return NULL;
26016 }
26017
26018
26019 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26020 PyObject *resultobj;
26021 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26022 wxDateSpan *result;
26023 PyObject * obj0 = 0 ;
26024 char *kwnames[] = {
26025 (char *) "self", NULL
26026 };
26027
26028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26030 if (SWIG_arg_fail(1)) SWIG_fail;
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 {
26034 wxDateSpan &_result_ref = (arg1)->operator -();
26035 result = (wxDateSpan *) &_result_ref;
26036 }
26037
26038 wxPyEndAllowThreads(__tstate);
26039 if (PyErr_Occurred()) SWIG_fail;
26040 }
26041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26042 return resultobj;
26043 fail:
26044 return NULL;
26045 }
26046
26047
26048 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26049 PyObject *resultobj;
26050 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26051 int arg2 ;
26052 wxDateSpan *result;
26053 PyObject * obj0 = 0 ;
26054 PyObject * obj1 = 0 ;
26055 char *kwnames[] = {
26056 (char *) "self",(char *) "factor", NULL
26057 };
26058
26059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26061 if (SWIG_arg_fail(1)) SWIG_fail;
26062 {
26063 arg2 = (int)(SWIG_As_int(obj1));
26064 if (SWIG_arg_fail(2)) SWIG_fail;
26065 }
26066 {
26067 PyThreadState* __tstate = wxPyBeginAllowThreads();
26068 {
26069 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26070 result = (wxDateSpan *) &_result_ref;
26071 }
26072
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj;
26085 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26086 wxDateSpan *arg2 = 0 ;
26087 wxDateSpan result;
26088 PyObject * obj0 = 0 ;
26089 PyObject * obj1 = 0 ;
26090 char *kwnames[] = {
26091 (char *) "self",(char *) "other", NULL
26092 };
26093
26094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26096 if (SWIG_arg_fail(1)) SWIG_fail;
26097 {
26098 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26099 if (SWIG_arg_fail(2)) SWIG_fail;
26100 if (arg2 == NULL) {
26101 SWIG_null_ref("wxDateSpan");
26102 }
26103 if (SWIG_arg_fail(2)) SWIG_fail;
26104 }
26105 {
26106 PyThreadState* __tstate = wxPyBeginAllowThreads();
26107 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26108
26109 wxPyEndAllowThreads(__tstate);
26110 if (PyErr_Occurred()) SWIG_fail;
26111 }
26112 {
26113 wxDateSpan * resultptr;
26114 resultptr = new wxDateSpan((wxDateSpan &)(result));
26115 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26116 }
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj;
26125 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26126 wxDateSpan *arg2 = 0 ;
26127 wxDateSpan result;
26128 PyObject * obj0 = 0 ;
26129 PyObject * obj1 = 0 ;
26130 char *kwnames[] = {
26131 (char *) "self",(char *) "other", NULL
26132 };
26133
26134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26136 if (SWIG_arg_fail(1)) SWIG_fail;
26137 {
26138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26139 if (SWIG_arg_fail(2)) SWIG_fail;
26140 if (arg2 == NULL) {
26141 SWIG_null_ref("wxDateSpan");
26142 }
26143 if (SWIG_arg_fail(2)) SWIG_fail;
26144 }
26145 {
26146 PyThreadState* __tstate = wxPyBeginAllowThreads();
26147 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26148
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 {
26153 wxDateSpan * resultptr;
26154 resultptr = new wxDateSpan((wxDateSpan &)(result));
26155 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26156 }
26157 return resultobj;
26158 fail:
26159 return NULL;
26160 }
26161
26162
26163 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26164 PyObject *resultobj;
26165 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26166 int arg2 ;
26167 wxDateSpan result;
26168 PyObject * obj0 = 0 ;
26169 PyObject * obj1 = 0 ;
26170 char *kwnames[] = {
26171 (char *) "self",(char *) "n", NULL
26172 };
26173
26174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26176 if (SWIG_arg_fail(1)) SWIG_fail;
26177 {
26178 arg2 = (int)(SWIG_As_int(obj1));
26179 if (SWIG_arg_fail(2)) SWIG_fail;
26180 }
26181 {
26182 PyThreadState* __tstate = wxPyBeginAllowThreads();
26183 result = wxDateSpan___mul__(arg1,arg2);
26184
26185 wxPyEndAllowThreads(__tstate);
26186 if (PyErr_Occurred()) SWIG_fail;
26187 }
26188 {
26189 wxDateSpan * resultptr;
26190 resultptr = new wxDateSpan((wxDateSpan &)(result));
26191 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26192 }
26193 return resultobj;
26194 fail:
26195 return NULL;
26196 }
26197
26198
26199 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26200 PyObject *resultobj;
26201 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26202 int arg2 ;
26203 wxDateSpan result;
26204 PyObject * obj0 = 0 ;
26205 PyObject * obj1 = 0 ;
26206 char *kwnames[] = {
26207 (char *) "self",(char *) "n", NULL
26208 };
26209
26210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26212 if (SWIG_arg_fail(1)) SWIG_fail;
26213 {
26214 arg2 = (int)(SWIG_As_int(obj1));
26215 if (SWIG_arg_fail(2)) SWIG_fail;
26216 }
26217 {
26218 PyThreadState* __tstate = wxPyBeginAllowThreads();
26219 result = wxDateSpan___rmul__(arg1,arg2);
26220
26221 wxPyEndAllowThreads(__tstate);
26222 if (PyErr_Occurred()) SWIG_fail;
26223 }
26224 {
26225 wxDateSpan * resultptr;
26226 resultptr = new wxDateSpan((wxDateSpan &)(result));
26227 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26228 }
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26236 PyObject *resultobj;
26237 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26238 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26239 bool result;
26240 PyObject * obj0 = 0 ;
26241 PyObject * obj1 = 0 ;
26242 char *kwnames[] = {
26243 (char *) "self",(char *) "other", NULL
26244 };
26245
26246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26248 if (SWIG_arg_fail(1)) SWIG_fail;
26249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26250 if (SWIG_arg_fail(2)) SWIG_fail;
26251 {
26252 PyThreadState* __tstate = wxPyBeginAllowThreads();
26253 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26254
26255 wxPyEndAllowThreads(__tstate);
26256 if (PyErr_Occurred()) SWIG_fail;
26257 }
26258 {
26259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26260 }
26261 return resultobj;
26262 fail:
26263 return NULL;
26264 }
26265
26266
26267 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26268 PyObject *resultobj;
26269 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26270 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26271 bool result;
26272 PyObject * obj0 = 0 ;
26273 PyObject * obj1 = 0 ;
26274 char *kwnames[] = {
26275 (char *) "self",(char *) "other", NULL
26276 };
26277
26278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26280 if (SWIG_arg_fail(1)) SWIG_fail;
26281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26282 if (SWIG_arg_fail(2)) SWIG_fail;
26283 {
26284 PyThreadState* __tstate = wxPyBeginAllowThreads();
26285 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26286
26287 wxPyEndAllowThreads(__tstate);
26288 if (PyErr_Occurred()) SWIG_fail;
26289 }
26290 {
26291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26292 }
26293 return resultobj;
26294 fail:
26295 return NULL;
26296 }
26297
26298
26299 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26300 PyObject *obj;
26301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26302 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26303 Py_INCREF(obj);
26304 return Py_BuildValue((char *)"");
26305 }
26306 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26307 PyObject *resultobj;
26308 long result;
26309 char *kwnames[] = {
26310 NULL
26311 };
26312
26313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 result = (long)wxGetLocalTime();
26317
26318 wxPyEndAllowThreads(__tstate);
26319 if (PyErr_Occurred()) SWIG_fail;
26320 }
26321 {
26322 resultobj = SWIG_From_long((long)(result));
26323 }
26324 return resultobj;
26325 fail:
26326 return NULL;
26327 }
26328
26329
26330 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26331 PyObject *resultobj;
26332 long result;
26333 char *kwnames[] = {
26334 NULL
26335 };
26336
26337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = (long)wxGetUTCTime();
26341
26342 wxPyEndAllowThreads(__tstate);
26343 if (PyErr_Occurred()) SWIG_fail;
26344 }
26345 {
26346 resultobj = SWIG_From_long((long)(result));
26347 }
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj;
26356 long result;
26357 char *kwnames[] = {
26358 NULL
26359 };
26360
26361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26362 {
26363 PyThreadState* __tstate = wxPyBeginAllowThreads();
26364 result = (long)wxGetCurrentTime();
26365
26366 wxPyEndAllowThreads(__tstate);
26367 if (PyErr_Occurred()) SWIG_fail;
26368 }
26369 {
26370 resultobj = SWIG_From_long((long)(result));
26371 }
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26379 PyObject *resultobj;
26380 wxLongLong result;
26381 char *kwnames[] = {
26382 NULL
26383 };
26384
26385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26386 {
26387 PyThreadState* __tstate = wxPyBeginAllowThreads();
26388 result = wxGetLocalTimeMillis();
26389
26390 wxPyEndAllowThreads(__tstate);
26391 if (PyErr_Occurred()) SWIG_fail;
26392 }
26393 {
26394 PyObject *hi, *lo, *shifter, *shifted;
26395 hi = PyLong_FromLong( (&result)->GetHi() );
26396 lo = PyLong_FromLong( (&result)->GetLo() );
26397 shifter = PyLong_FromLong(32);
26398 shifted = PyNumber_Lshift(hi, shifter);
26399 resultobj = PyNumber_Or(shifted, lo);
26400 Py_DECREF(hi);
26401 Py_DECREF(lo);
26402 Py_DECREF(shifter);
26403 Py_DECREF(shifted);
26404 }
26405 return resultobj;
26406 fail:
26407 return NULL;
26408 }
26409
26410
26411 static int _wrap_DefaultDateTime_set(PyObject *) {
26412 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26413 return 1;
26414 }
26415
26416
26417 static PyObject *_wrap_DefaultDateTime_get(void) {
26418 PyObject *pyobj;
26419
26420 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26421 return pyobj;
26422 }
26423
26424
26425 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26426 PyObject *resultobj;
26427 wxDataFormatId arg1 ;
26428 wxDataFormat *result;
26429 PyObject * obj0 = 0 ;
26430 char *kwnames[] = {
26431 (char *) "type", NULL
26432 };
26433
26434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26435 {
26436 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26437 if (SWIG_arg_fail(1)) SWIG_fail;
26438 }
26439 {
26440 PyThreadState* __tstate = wxPyBeginAllowThreads();
26441 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26442
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26454 PyObject *resultobj;
26455 wxString *arg1 = 0 ;
26456 wxDataFormat *result;
26457 bool temp1 = false ;
26458 PyObject * obj0 = 0 ;
26459 char *kwnames[] = {
26460 (char *) "format", NULL
26461 };
26462
26463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26464 {
26465 arg1 = wxString_in_helper(obj0);
26466 if (arg1 == NULL) SWIG_fail;
26467 temp1 = true;
26468 }
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26477 {
26478 if (temp1)
26479 delete arg1;
26480 }
26481 return resultobj;
26482 fail:
26483 {
26484 if (temp1)
26485 delete arg1;
26486 }
26487 return NULL;
26488 }
26489
26490
26491 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26492 PyObject *resultobj;
26493 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26494 PyObject * obj0 = 0 ;
26495 char *kwnames[] = {
26496 (char *) "self", NULL
26497 };
26498
26499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26501 if (SWIG_arg_fail(1)) SWIG_fail;
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 delete arg1;
26505
26506 wxPyEndAllowThreads(__tstate);
26507 if (PyErr_Occurred()) SWIG_fail;
26508 }
26509 Py_INCREF(Py_None); resultobj = Py_None;
26510 return resultobj;
26511 fail:
26512 return NULL;
26513 }
26514
26515
26516 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26517 PyObject *resultobj;
26518 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26519 wxDataFormatId arg2 ;
26520 bool result;
26521 PyObject * obj0 = 0 ;
26522 PyObject * obj1 = 0 ;
26523
26524 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26526 if (SWIG_arg_fail(1)) SWIG_fail;
26527 {
26528 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26529 if (SWIG_arg_fail(2)) SWIG_fail;
26530 }
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26534
26535 wxPyEndAllowThreads(__tstate);
26536 if (PyErr_Occurred()) SWIG_fail;
26537 }
26538 {
26539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26540 }
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26548 PyObject *resultobj;
26549 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26550 wxDataFormatId arg2 ;
26551 bool result;
26552 PyObject * obj0 = 0 ;
26553 PyObject * obj1 = 0 ;
26554
26555 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26557 if (SWIG_arg_fail(1)) SWIG_fail;
26558 {
26559 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26560 if (SWIG_arg_fail(2)) SWIG_fail;
26561 }
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26565
26566 wxPyEndAllowThreads(__tstate);
26567 if (PyErr_Occurred()) SWIG_fail;
26568 }
26569 {
26570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26571 }
26572 return resultobj;
26573 fail:
26574 return NULL;
26575 }
26576
26577
26578 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26579 PyObject *resultobj;
26580 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26581 wxDataFormat *arg2 = 0 ;
26582 bool result;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585
26586 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26588 if (SWIG_arg_fail(1)) SWIG_fail;
26589 {
26590 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26591 if (SWIG_arg_fail(2)) SWIG_fail;
26592 if (arg2 == NULL) {
26593 SWIG_null_ref("wxDataFormat");
26594 }
26595 if (SWIG_arg_fail(2)) SWIG_fail;
26596 }
26597 {
26598 PyThreadState* __tstate = wxPyBeginAllowThreads();
26599 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26600
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 {
26605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26606 }
26607 return resultobj;
26608 fail:
26609 return NULL;
26610 }
26611
26612
26613 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26614 int argc;
26615 PyObject *argv[3];
26616 int ii;
26617
26618 argc = PyObject_Length(args);
26619 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26620 argv[ii] = PyTuple_GetItem(args,ii);
26621 }
26622 if (argc == 2) {
26623 int _v;
26624 {
26625 void *ptr;
26626 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26627 _v = 0;
26628 PyErr_Clear();
26629 } else {
26630 _v = 1;
26631 }
26632 }
26633 if (_v) {
26634 {
26635 void *ptr = 0;
26636 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26637 _v = 0;
26638 PyErr_Clear();
26639 } else {
26640 _v = (ptr != 0);
26641 }
26642 }
26643 if (_v) {
26644 return _wrap_DataFormat___eq____SWIG_1(self,args);
26645 }
26646 }
26647 }
26648 if (argc == 2) {
26649 int _v;
26650 {
26651 void *ptr;
26652 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26653 _v = 0;
26654 PyErr_Clear();
26655 } else {
26656 _v = 1;
26657 }
26658 }
26659 if (_v) {
26660 _v = SWIG_Check_int(argv[1]);
26661 if (_v) {
26662 return _wrap_DataFormat___eq____SWIG_0(self,args);
26663 }
26664 }
26665 }
26666
26667 Py_INCREF(Py_NotImplemented);
26668 return Py_NotImplemented;
26669 }
26670
26671
26672 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26673 PyObject *resultobj;
26674 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26675 wxDataFormat *arg2 = 0 ;
26676 bool result;
26677 PyObject * obj0 = 0 ;
26678 PyObject * obj1 = 0 ;
26679
26680 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26682 if (SWIG_arg_fail(1)) SWIG_fail;
26683 {
26684 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26685 if (SWIG_arg_fail(2)) SWIG_fail;
26686 if (arg2 == NULL) {
26687 SWIG_null_ref("wxDataFormat");
26688 }
26689 if (SWIG_arg_fail(2)) SWIG_fail;
26690 }
26691 {
26692 PyThreadState* __tstate = wxPyBeginAllowThreads();
26693 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26694
26695 wxPyEndAllowThreads(__tstate);
26696 if (PyErr_Occurred()) SWIG_fail;
26697 }
26698 {
26699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26700 }
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26708 int argc;
26709 PyObject *argv[3];
26710 int ii;
26711
26712 argc = PyObject_Length(args);
26713 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26714 argv[ii] = PyTuple_GetItem(args,ii);
26715 }
26716 if (argc == 2) {
26717 int _v;
26718 {
26719 void *ptr;
26720 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26721 _v = 0;
26722 PyErr_Clear();
26723 } else {
26724 _v = 1;
26725 }
26726 }
26727 if (_v) {
26728 {
26729 void *ptr = 0;
26730 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26731 _v = 0;
26732 PyErr_Clear();
26733 } else {
26734 _v = (ptr != 0);
26735 }
26736 }
26737 if (_v) {
26738 return _wrap_DataFormat___ne____SWIG_1(self,args);
26739 }
26740 }
26741 }
26742 if (argc == 2) {
26743 int _v;
26744 {
26745 void *ptr;
26746 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26747 _v = 0;
26748 PyErr_Clear();
26749 } else {
26750 _v = 1;
26751 }
26752 }
26753 if (_v) {
26754 _v = SWIG_Check_int(argv[1]);
26755 if (_v) {
26756 return _wrap_DataFormat___ne____SWIG_0(self,args);
26757 }
26758 }
26759 }
26760
26761 Py_INCREF(Py_NotImplemented);
26762 return Py_NotImplemented;
26763 }
26764
26765
26766 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26767 PyObject *resultobj;
26768 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26769 wxDataFormatId arg2 ;
26770 PyObject * obj0 = 0 ;
26771 PyObject * obj1 = 0 ;
26772 char *kwnames[] = {
26773 (char *) "self",(char *) "format", NULL
26774 };
26775
26776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26778 if (SWIG_arg_fail(1)) SWIG_fail;
26779 {
26780 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26781 if (SWIG_arg_fail(2)) SWIG_fail;
26782 }
26783 {
26784 PyThreadState* __tstate = wxPyBeginAllowThreads();
26785 (arg1)->SetType((wxDataFormatId )arg2);
26786
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 Py_INCREF(Py_None); resultobj = Py_None;
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26798 PyObject *resultobj;
26799 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26800 wxDataFormatId result;
26801 PyObject * obj0 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 PyThreadState* __tstate = wxPyBeginAllowThreads();
26811 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26812
26813 wxPyEndAllowThreads(__tstate);
26814 if (PyErr_Occurred()) SWIG_fail;
26815 }
26816 resultobj = SWIG_From_int((result));
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26824 PyObject *resultobj;
26825 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26826 wxString result;
26827 PyObject * obj0 = 0 ;
26828 char *kwnames[] = {
26829 (char *) "self", NULL
26830 };
26831
26832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26834 if (SWIG_arg_fail(1)) SWIG_fail;
26835 {
26836 PyThreadState* __tstate = wxPyBeginAllowThreads();
26837 result = ((wxDataFormat const *)arg1)->GetId();
26838
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 {
26843 #if wxUSE_UNICODE
26844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26845 #else
26846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26847 #endif
26848 }
26849 return resultobj;
26850 fail:
26851 return NULL;
26852 }
26853
26854
26855 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26856 PyObject *resultobj;
26857 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26858 wxString *arg2 = 0 ;
26859 bool temp2 = false ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 char *kwnames[] = {
26863 (char *) "self",(char *) "format", NULL
26864 };
26865
26866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26868 if (SWIG_arg_fail(1)) SWIG_fail;
26869 {
26870 arg2 = wxString_in_helper(obj1);
26871 if (arg2 == NULL) SWIG_fail;
26872 temp2 = true;
26873 }
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 (arg1)->SetId((wxString const &)*arg2);
26877
26878 wxPyEndAllowThreads(__tstate);
26879 if (PyErr_Occurred()) SWIG_fail;
26880 }
26881 Py_INCREF(Py_None); resultobj = Py_None;
26882 {
26883 if (temp2)
26884 delete arg2;
26885 }
26886 return resultobj;
26887 fail:
26888 {
26889 if (temp2)
26890 delete arg2;
26891 }
26892 return NULL;
26893 }
26894
26895
26896 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26897 PyObject *obj;
26898 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26899 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26900 Py_INCREF(obj);
26901 return Py_BuildValue((char *)"");
26902 }
26903 static int _wrap_FormatInvalid_set(PyObject *) {
26904 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26905 return 1;
26906 }
26907
26908
26909 static PyObject *_wrap_FormatInvalid_get(void) {
26910 PyObject *pyobj;
26911
26912 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26913 return pyobj;
26914 }
26915
26916
26917 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj;
26919 wxDataObject *arg1 = (wxDataObject *) 0 ;
26920 PyObject * obj0 = 0 ;
26921 char *kwnames[] = {
26922 (char *) "self", NULL
26923 };
26924
26925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26927 if (SWIG_arg_fail(1)) SWIG_fail;
26928 {
26929 PyThreadState* __tstate = wxPyBeginAllowThreads();
26930 delete arg1;
26931
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 Py_INCREF(Py_None); resultobj = Py_None;
26936 return resultobj;
26937 fail:
26938 return NULL;
26939 }
26940
26941
26942 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26943 PyObject *resultobj;
26944 wxDataObject *arg1 = (wxDataObject *) 0 ;
26945 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26946 SwigValueWrapper<wxDataFormat > result;
26947 PyObject * obj0 = 0 ;
26948 PyObject * obj1 = 0 ;
26949 char *kwnames[] = {
26950 (char *) "self",(char *) "dir", NULL
26951 };
26952
26953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26955 if (SWIG_arg_fail(1)) SWIG_fail;
26956 if (obj1) {
26957 {
26958 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26959 if (SWIG_arg_fail(2)) SWIG_fail;
26960 }
26961 }
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26965
26966 wxPyEndAllowThreads(__tstate);
26967 if (PyErr_Occurred()) SWIG_fail;
26968 }
26969 {
26970 wxDataFormat * resultptr;
26971 resultptr = new wxDataFormat((wxDataFormat &)(result));
26972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26973 }
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj;
26982 wxDataObject *arg1 = (wxDataObject *) 0 ;
26983 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26984 size_t result;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char *kwnames[] = {
26988 (char *) "self",(char *) "dir", NULL
26989 };
26990
26991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26993 if (SWIG_arg_fail(1)) SWIG_fail;
26994 if (obj1) {
26995 {
26996 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26997 if (SWIG_arg_fail(2)) SWIG_fail;
26998 }
26999 }
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27003
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 {
27008 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27009 }
27010 return resultobj;
27011 fail:
27012 return NULL;
27013 }
27014
27015
27016 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27017 PyObject *resultobj;
27018 wxDataObject *arg1 = (wxDataObject *) 0 ;
27019 wxDataFormat *arg2 = 0 ;
27020 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27021 bool result;
27022 PyObject * obj0 = 0 ;
27023 PyObject * obj1 = 0 ;
27024 PyObject * obj2 = 0 ;
27025 char *kwnames[] = {
27026 (char *) "self",(char *) "format",(char *) "dir", NULL
27027 };
27028
27029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27031 if (SWIG_arg_fail(1)) SWIG_fail;
27032 {
27033 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27034 if (SWIG_arg_fail(2)) SWIG_fail;
27035 if (arg2 == NULL) {
27036 SWIG_null_ref("wxDataFormat");
27037 }
27038 if (SWIG_arg_fail(2)) SWIG_fail;
27039 }
27040 if (obj2) {
27041 {
27042 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27043 if (SWIG_arg_fail(3)) SWIG_fail;
27044 }
27045 }
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27055 }
27056 return resultobj;
27057 fail:
27058 return NULL;
27059 }
27060
27061
27062 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27063 PyObject *resultobj;
27064 wxDataObject *arg1 = (wxDataObject *) 0 ;
27065 wxDataFormat *arg2 = 0 ;
27066 size_t result;
27067 PyObject * obj0 = 0 ;
27068 PyObject * obj1 = 0 ;
27069 char *kwnames[] = {
27070 (char *) "self",(char *) "format", NULL
27071 };
27072
27073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27075 if (SWIG_arg_fail(1)) SWIG_fail;
27076 {
27077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27078 if (SWIG_arg_fail(2)) SWIG_fail;
27079 if (arg2 == NULL) {
27080 SWIG_null_ref("wxDataFormat");
27081 }
27082 if (SWIG_arg_fail(2)) SWIG_fail;
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 {
27092 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27093 }
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27101 PyObject *resultobj;
27102 wxDataObject *arg1 = (wxDataObject *) 0 ;
27103 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27104 PyObject *result;
27105 PyObject * obj0 = 0 ;
27106 PyObject * obj1 = 0 ;
27107 char *kwnames[] = {
27108 (char *) "self",(char *) "dir", NULL
27109 };
27110
27111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27113 if (SWIG_arg_fail(1)) SWIG_fail;
27114 if (obj1) {
27115 {
27116 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27117 if (SWIG_arg_fail(2)) SWIG_fail;
27118 }
27119 }
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27123
27124 wxPyEndAllowThreads(__tstate);
27125 if (PyErr_Occurred()) SWIG_fail;
27126 }
27127 resultobj = result;
27128 return resultobj;
27129 fail:
27130 return NULL;
27131 }
27132
27133
27134 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27135 PyObject *resultobj;
27136 wxDataObject *arg1 = (wxDataObject *) 0 ;
27137 wxDataFormat *arg2 = 0 ;
27138 PyObject *result;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char *kwnames[] = {
27142 (char *) "self",(char *) "format", NULL
27143 };
27144
27145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27147 if (SWIG_arg_fail(1)) SWIG_fail;
27148 {
27149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27150 if (SWIG_arg_fail(2)) SWIG_fail;
27151 if (arg2 == NULL) {
27152 SWIG_null_ref("wxDataFormat");
27153 }
27154 if (SWIG_arg_fail(2)) SWIG_fail;
27155 }
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27159
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 resultobj = result;
27164 return resultobj;
27165 fail:
27166 return NULL;
27167 }
27168
27169
27170 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27171 PyObject *resultobj;
27172 wxDataObject *arg1 = (wxDataObject *) 0 ;
27173 wxDataFormat *arg2 = 0 ;
27174 PyObject *arg3 = (PyObject *) 0 ;
27175 bool result;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 PyObject * obj2 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self",(char *) "format",(char *) "data", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27188 if (SWIG_arg_fail(2)) SWIG_fail;
27189 if (arg2 == NULL) {
27190 SWIG_null_ref("wxDataFormat");
27191 }
27192 if (SWIG_arg_fail(2)) SWIG_fail;
27193 }
27194 arg3 = obj2;
27195 {
27196 PyThreadState* __tstate = wxPyBeginAllowThreads();
27197 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27198
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 {
27203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27204 }
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27212 PyObject *obj;
27213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27214 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27215 Py_INCREF(obj);
27216 return Py_BuildValue((char *)"");
27217 }
27218 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27219 PyObject *resultobj;
27220 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27221 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27222 wxDataObjectSimple *result;
27223 PyObject * obj0 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "format", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27229 if (obj0) {
27230 {
27231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27232 if (SWIG_arg_fail(1)) SWIG_fail;
27233 if (arg1 == NULL) {
27234 SWIG_null_ref("wxDataFormat");
27235 }
27236 if (SWIG_arg_fail(1)) SWIG_fail;
27237 }
27238 }
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27242
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27256 wxDataFormat *result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 {
27268 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27269 result = (wxDataFormat *) &_result_ref;
27270 }
27271
27272 wxPyEndAllowThreads(__tstate);
27273 if (PyErr_Occurred()) SWIG_fail;
27274 }
27275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27276 return resultobj;
27277 fail:
27278 return NULL;
27279 }
27280
27281
27282 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27283 PyObject *resultobj;
27284 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27285 wxDataFormat *arg2 = 0 ;
27286 PyObject * obj0 = 0 ;
27287 PyObject * obj1 = 0 ;
27288 char *kwnames[] = {
27289 (char *) "self",(char *) "format", NULL
27290 };
27291
27292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27294 if (SWIG_arg_fail(1)) SWIG_fail;
27295 {
27296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27297 if (SWIG_arg_fail(2)) SWIG_fail;
27298 if (arg2 == NULL) {
27299 SWIG_null_ref("wxDataFormat");
27300 }
27301 if (SWIG_arg_fail(2)) SWIG_fail;
27302 }
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27306
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 Py_INCREF(Py_None); resultobj = Py_None;
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27318 PyObject *resultobj;
27319 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27320 size_t result;
27321 PyObject * obj0 = 0 ;
27322 char *kwnames[] = {
27323 (char *) "self", NULL
27324 };
27325
27326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27328 if (SWIG_arg_fail(1)) SWIG_fail;
27329 {
27330 PyThreadState* __tstate = wxPyBeginAllowThreads();
27331 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27332
27333 wxPyEndAllowThreads(__tstate);
27334 if (PyErr_Occurred()) SWIG_fail;
27335 }
27336 {
27337 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27338 }
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27346 PyObject *resultobj;
27347 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27348 PyObject *result;
27349 PyObject * obj0 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "self", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(1)) SWIG_fail;
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = result;
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj;
27373 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27374 PyObject *arg2 = (PyObject *) 0 ;
27375 bool result;
27376 PyObject * obj0 = 0 ;
27377 PyObject * obj1 = 0 ;
27378 char *kwnames[] = {
27379 (char *) "self",(char *) "data", NULL
27380 };
27381
27382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27384 if (SWIG_arg_fail(1)) SWIG_fail;
27385 arg2 = obj1;
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27389
27390 wxPyEndAllowThreads(__tstate);
27391 if (PyErr_Occurred()) SWIG_fail;
27392 }
27393 {
27394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27395 }
27396 return resultobj;
27397 fail:
27398 return NULL;
27399 }
27400
27401
27402 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27403 PyObject *obj;
27404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27405 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27406 Py_INCREF(obj);
27407 return Py_BuildValue((char *)"");
27408 }
27409 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27410 PyObject *resultobj;
27411 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27412 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27413 wxPyDataObjectSimple *result;
27414 PyObject * obj0 = 0 ;
27415 char *kwnames[] = {
27416 (char *) "format", NULL
27417 };
27418
27419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27420 if (obj0) {
27421 {
27422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27423 if (SWIG_arg_fail(1)) SWIG_fail;
27424 if (arg1 == NULL) {
27425 SWIG_null_ref("wxDataFormat");
27426 }
27427 if (SWIG_arg_fail(1)) SWIG_fail;
27428 }
27429 }
27430 {
27431 PyThreadState* __tstate = wxPyBeginAllowThreads();
27432 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27433
27434 wxPyEndAllowThreads(__tstate);
27435 if (PyErr_Occurred()) SWIG_fail;
27436 }
27437 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj;
27446 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27447 PyObject *arg2 = (PyObject *) 0 ;
27448 PyObject *arg3 = (PyObject *) 0 ;
27449 PyObject * obj0 = 0 ;
27450 PyObject * obj1 = 0 ;
27451 PyObject * obj2 = 0 ;
27452 char *kwnames[] = {
27453 (char *) "self",(char *) "self",(char *) "_class", NULL
27454 };
27455
27456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27458 if (SWIG_arg_fail(1)) SWIG_fail;
27459 arg2 = obj1;
27460 arg3 = obj2;
27461 {
27462 PyThreadState* __tstate = wxPyBeginAllowThreads();
27463 (arg1)->_setCallbackInfo(arg2,arg3);
27464
27465 wxPyEndAllowThreads(__tstate);
27466 if (PyErr_Occurred()) SWIG_fail;
27467 }
27468 Py_INCREF(Py_None); resultobj = Py_None;
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27476 PyObject *obj;
27477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27478 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27479 Py_INCREF(obj);
27480 return Py_BuildValue((char *)"");
27481 }
27482 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27483 PyObject *resultobj;
27484 wxDataObjectComposite *result;
27485 char *kwnames[] = {
27486 NULL
27487 };
27488
27489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27493
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27498 return resultobj;
27499 fail:
27500 return NULL;
27501 }
27502
27503
27504 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27505 PyObject *resultobj;
27506 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27507 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27508 bool arg3 = (bool) false ;
27509 PyObject * obj0 = 0 ;
27510 PyObject * obj1 = 0 ;
27511 PyObject * obj2 = 0 ;
27512 char *kwnames[] = {
27513 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27514 };
27515
27516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27518 if (SWIG_arg_fail(1)) SWIG_fail;
27519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27520 if (SWIG_arg_fail(2)) SWIG_fail;
27521 if (obj2) {
27522 {
27523 arg3 = (bool)(SWIG_As_bool(obj2));
27524 if (SWIG_arg_fail(3)) SWIG_fail;
27525 }
27526 }
27527 {
27528 PyThreadState* __tstate = wxPyBeginAllowThreads();
27529 (arg1)->Add(arg2,arg3);
27530
27531 wxPyEndAllowThreads(__tstate);
27532 if (PyErr_Occurred()) SWIG_fail;
27533 }
27534 Py_INCREF(Py_None); resultobj = Py_None;
27535 return resultobj;
27536 fail:
27537 return NULL;
27538 }
27539
27540
27541 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27542 PyObject *obj;
27543 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27544 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27545 Py_INCREF(obj);
27546 return Py_BuildValue((char *)"");
27547 }
27548 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27549 PyObject *resultobj;
27550 wxString const &arg1_defvalue = wxPyEmptyString ;
27551 wxString *arg1 = (wxString *) &arg1_defvalue ;
27552 wxTextDataObject *result;
27553 bool temp1 = false ;
27554 PyObject * obj0 = 0 ;
27555 char *kwnames[] = {
27556 (char *) "text", NULL
27557 };
27558
27559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27560 if (obj0) {
27561 {
27562 arg1 = wxString_in_helper(obj0);
27563 if (arg1 == NULL) SWIG_fail;
27564 temp1 = true;
27565 }
27566 }
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27570
27571 wxPyEndAllowThreads(__tstate);
27572 if (PyErr_Occurred()) SWIG_fail;
27573 }
27574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27575 {
27576 if (temp1)
27577 delete arg1;
27578 }
27579 return resultobj;
27580 fail:
27581 {
27582 if (temp1)
27583 delete arg1;
27584 }
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj;
27591 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27592 size_t result;
27593 PyObject * obj0 = 0 ;
27594 char *kwnames[] = {
27595 (char *) "self", NULL
27596 };
27597
27598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27600 if (SWIG_arg_fail(1)) SWIG_fail;
27601 {
27602 PyThreadState* __tstate = wxPyBeginAllowThreads();
27603 result = (size_t)(arg1)->GetTextLength();
27604
27605 wxPyEndAllowThreads(__tstate);
27606 if (PyErr_Occurred()) SWIG_fail;
27607 }
27608 {
27609 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27610 }
27611 return resultobj;
27612 fail:
27613 return NULL;
27614 }
27615
27616
27617 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27618 PyObject *resultobj;
27619 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27620 wxString result;
27621 PyObject * obj0 = 0 ;
27622 char *kwnames[] = {
27623 (char *) "self", NULL
27624 };
27625
27626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27628 if (SWIG_arg_fail(1)) SWIG_fail;
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 result = (arg1)->GetText();
27632
27633 wxPyEndAllowThreads(__tstate);
27634 if (PyErr_Occurred()) SWIG_fail;
27635 }
27636 {
27637 #if wxUSE_UNICODE
27638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27639 #else
27640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27641 #endif
27642 }
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27650 PyObject *resultobj;
27651 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27652 wxString *arg2 = 0 ;
27653 bool temp2 = false ;
27654 PyObject * obj0 = 0 ;
27655 PyObject * obj1 = 0 ;
27656 char *kwnames[] = {
27657 (char *) "self",(char *) "text", NULL
27658 };
27659
27660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27662 if (SWIG_arg_fail(1)) SWIG_fail;
27663 {
27664 arg2 = wxString_in_helper(obj1);
27665 if (arg2 == NULL) SWIG_fail;
27666 temp2 = true;
27667 }
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 (arg1)->SetText((wxString const &)*arg2);
27671
27672 wxPyEndAllowThreads(__tstate);
27673 if (PyErr_Occurred()) SWIG_fail;
27674 }
27675 Py_INCREF(Py_None); resultobj = Py_None;
27676 {
27677 if (temp2)
27678 delete arg2;
27679 }
27680 return resultobj;
27681 fail:
27682 {
27683 if (temp2)
27684 delete arg2;
27685 }
27686 return NULL;
27687 }
27688
27689
27690 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27691 PyObject *obj;
27692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27693 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27694 Py_INCREF(obj);
27695 return Py_BuildValue((char *)"");
27696 }
27697 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxString const &arg1_defvalue = wxPyEmptyString ;
27700 wxString *arg1 = (wxString *) &arg1_defvalue ;
27701 wxPyTextDataObject *result;
27702 bool temp1 = false ;
27703 PyObject * obj0 = 0 ;
27704 char *kwnames[] = {
27705 (char *) "text", NULL
27706 };
27707
27708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27709 if (obj0) {
27710 {
27711 arg1 = wxString_in_helper(obj0);
27712 if (arg1 == NULL) SWIG_fail;
27713 temp1 = true;
27714 }
27715 }
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27719
27720 wxPyEndAllowThreads(__tstate);
27721 if (PyErr_Occurred()) SWIG_fail;
27722 }
27723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27724 {
27725 if (temp1)
27726 delete arg1;
27727 }
27728 return resultobj;
27729 fail:
27730 {
27731 if (temp1)
27732 delete arg1;
27733 }
27734 return NULL;
27735 }
27736
27737
27738 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27739 PyObject *resultobj;
27740 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27741 PyObject *arg2 = (PyObject *) 0 ;
27742 PyObject *arg3 = (PyObject *) 0 ;
27743 PyObject * obj0 = 0 ;
27744 PyObject * obj1 = 0 ;
27745 PyObject * obj2 = 0 ;
27746 char *kwnames[] = {
27747 (char *) "self",(char *) "self",(char *) "_class", NULL
27748 };
27749
27750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27752 if (SWIG_arg_fail(1)) SWIG_fail;
27753 arg2 = obj1;
27754 arg3 = obj2;
27755 {
27756 PyThreadState* __tstate = wxPyBeginAllowThreads();
27757 (arg1)->_setCallbackInfo(arg2,arg3);
27758
27759 wxPyEndAllowThreads(__tstate);
27760 if (PyErr_Occurred()) SWIG_fail;
27761 }
27762 Py_INCREF(Py_None); resultobj = Py_None;
27763 return resultobj;
27764 fail:
27765 return NULL;
27766 }
27767
27768
27769 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27770 PyObject *obj;
27771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27772 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27773 Py_INCREF(obj);
27774 return Py_BuildValue((char *)"");
27775 }
27776 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27777 PyObject *resultobj;
27778 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27779 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27780 wxBitmapDataObject *result;
27781 PyObject * obj0 = 0 ;
27782 char *kwnames[] = {
27783 (char *) "bitmap", NULL
27784 };
27785
27786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27787 if (obj0) {
27788 {
27789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27790 if (SWIG_arg_fail(1)) SWIG_fail;
27791 if (arg1 == NULL) {
27792 SWIG_null_ref("wxBitmap");
27793 }
27794 if (SWIG_arg_fail(1)) SWIG_fail;
27795 }
27796 }
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27800
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27812 PyObject *resultobj;
27813 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27814 wxBitmap result;
27815 PyObject * obj0 = 0 ;
27816 char *kwnames[] = {
27817 (char *) "self", NULL
27818 };
27819
27820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27822 if (SWIG_arg_fail(1)) SWIG_fail;
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27826
27827 wxPyEndAllowThreads(__tstate);
27828 if (PyErr_Occurred()) SWIG_fail;
27829 }
27830 {
27831 wxBitmap * resultptr;
27832 resultptr = new wxBitmap((wxBitmap &)(result));
27833 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27834 }
27835 return resultobj;
27836 fail:
27837 return NULL;
27838 }
27839
27840
27841 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27842 PyObject *resultobj;
27843 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27844 wxBitmap *arg2 = 0 ;
27845 PyObject * obj0 = 0 ;
27846 PyObject * obj1 = 0 ;
27847 char *kwnames[] = {
27848 (char *) "self",(char *) "bitmap", NULL
27849 };
27850
27851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27853 if (SWIG_arg_fail(1)) SWIG_fail;
27854 {
27855 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27856 if (SWIG_arg_fail(2)) SWIG_fail;
27857 if (arg2 == NULL) {
27858 SWIG_null_ref("wxBitmap");
27859 }
27860 if (SWIG_arg_fail(2)) SWIG_fail;
27861 }
27862 {
27863 PyThreadState* __tstate = wxPyBeginAllowThreads();
27864 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27865
27866 wxPyEndAllowThreads(__tstate);
27867 if (PyErr_Occurred()) SWIG_fail;
27868 }
27869 Py_INCREF(Py_None); resultobj = Py_None;
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27877 PyObject *obj;
27878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27879 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27880 Py_INCREF(obj);
27881 return Py_BuildValue((char *)"");
27882 }
27883 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27884 PyObject *resultobj;
27885 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27886 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27887 wxPyBitmapDataObject *result;
27888 PyObject * obj0 = 0 ;
27889 char *kwnames[] = {
27890 (char *) "bitmap", NULL
27891 };
27892
27893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27894 if (obj0) {
27895 {
27896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27897 if (SWIG_arg_fail(1)) SWIG_fail;
27898 if (arg1 == NULL) {
27899 SWIG_null_ref("wxBitmap");
27900 }
27901 if (SWIG_arg_fail(1)) SWIG_fail;
27902 }
27903 }
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27907
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27919 PyObject *resultobj;
27920 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27921 PyObject *arg2 = (PyObject *) 0 ;
27922 PyObject *arg3 = (PyObject *) 0 ;
27923 PyObject * obj0 = 0 ;
27924 PyObject * obj1 = 0 ;
27925 PyObject * obj2 = 0 ;
27926 char *kwnames[] = {
27927 (char *) "self",(char *) "self",(char *) "_class", NULL
27928 };
27929
27930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27932 if (SWIG_arg_fail(1)) SWIG_fail;
27933 arg2 = obj1;
27934 arg3 = obj2;
27935 {
27936 PyThreadState* __tstate = wxPyBeginAllowThreads();
27937 (arg1)->_setCallbackInfo(arg2,arg3);
27938
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 Py_INCREF(Py_None); resultobj = Py_None;
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27950 PyObject *obj;
27951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27952 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27953 Py_INCREF(obj);
27954 return Py_BuildValue((char *)"");
27955 }
27956 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27957 PyObject *resultobj;
27958 wxFileDataObject *result;
27959 char *kwnames[] = {
27960 NULL
27961 };
27962
27963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 result = (wxFileDataObject *)new wxFileDataObject();
27967
27968 wxPyEndAllowThreads(__tstate);
27969 if (PyErr_Occurred()) SWIG_fail;
27970 }
27971 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27972 return resultobj;
27973 fail:
27974 return NULL;
27975 }
27976
27977
27978 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27979 PyObject *resultobj;
27980 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27981 wxArrayString *result;
27982 PyObject * obj0 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 {
27993 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27994 result = (wxArrayString *) &_result_ref;
27995 }
27996
27997 wxPyEndAllowThreads(__tstate);
27998 if (PyErr_Occurred()) SWIG_fail;
27999 }
28000 {
28001 resultobj = wxArrayString2PyList_helper(*result);
28002 }
28003 return resultobj;
28004 fail:
28005 return NULL;
28006 }
28007
28008
28009 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28010 PyObject *resultobj;
28011 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28012 wxString *arg2 = 0 ;
28013 bool temp2 = false ;
28014 PyObject * obj0 = 0 ;
28015 PyObject * obj1 = 0 ;
28016 char *kwnames[] = {
28017 (char *) "self",(char *) "filename", NULL
28018 };
28019
28020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28022 if (SWIG_arg_fail(1)) SWIG_fail;
28023 {
28024 arg2 = wxString_in_helper(obj1);
28025 if (arg2 == NULL) SWIG_fail;
28026 temp2 = true;
28027 }
28028 {
28029 PyThreadState* __tstate = wxPyBeginAllowThreads();
28030 (arg1)->AddFile((wxString const &)*arg2);
28031
28032 wxPyEndAllowThreads(__tstate);
28033 if (PyErr_Occurred()) SWIG_fail;
28034 }
28035 Py_INCREF(Py_None); resultobj = Py_None;
28036 {
28037 if (temp2)
28038 delete arg2;
28039 }
28040 return resultobj;
28041 fail:
28042 {
28043 if (temp2)
28044 delete arg2;
28045 }
28046 return NULL;
28047 }
28048
28049
28050 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28051 PyObject *obj;
28052 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28053 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28054 Py_INCREF(obj);
28055 return Py_BuildValue((char *)"");
28056 }
28057 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28058 PyObject *resultobj;
28059 wxDataFormat *arg1 = 0 ;
28060 wxCustomDataObject *result;
28061 PyObject * obj0 = 0 ;
28062
28063 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28064 {
28065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28066 if (SWIG_arg_fail(1)) SWIG_fail;
28067 if (arg1 == NULL) {
28068 SWIG_null_ref("wxDataFormat");
28069 }
28070 if (SWIG_arg_fail(1)) SWIG_fail;
28071 }
28072 {
28073 PyThreadState* __tstate = wxPyBeginAllowThreads();
28074 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28075
28076 wxPyEndAllowThreads(__tstate);
28077 if (PyErr_Occurred()) SWIG_fail;
28078 }
28079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28080 return resultobj;
28081 fail:
28082 return NULL;
28083 }
28084
28085
28086 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28087 PyObject *resultobj;
28088 wxString *arg1 = 0 ;
28089 wxCustomDataObject *result;
28090 bool temp1 = false ;
28091 PyObject * obj0 = 0 ;
28092
28093 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28094 {
28095 arg1 = wxString_in_helper(obj0);
28096 if (arg1 == NULL) SWIG_fail;
28097 temp1 = true;
28098 }
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28102
28103 wxPyEndAllowThreads(__tstate);
28104 if (PyErr_Occurred()) SWIG_fail;
28105 }
28106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28107 {
28108 if (temp1)
28109 delete arg1;
28110 }
28111 return resultobj;
28112 fail:
28113 {
28114 if (temp1)
28115 delete arg1;
28116 }
28117 return NULL;
28118 }
28119
28120
28121 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28122 PyObject *resultobj;
28123 wxCustomDataObject *result;
28124
28125 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28126 {
28127 PyThreadState* __tstate = wxPyBeginAllowThreads();
28128 result = (wxCustomDataObject *)new wxCustomDataObject();
28129
28130 wxPyEndAllowThreads(__tstate);
28131 if (PyErr_Occurred()) SWIG_fail;
28132 }
28133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28134 return resultobj;
28135 fail:
28136 return NULL;
28137 }
28138
28139
28140 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28141 int argc;
28142 PyObject *argv[2];
28143 int ii;
28144
28145 argc = PyObject_Length(args);
28146 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28147 argv[ii] = PyTuple_GetItem(args,ii);
28148 }
28149 if (argc == 0) {
28150 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28151 }
28152 if (argc == 1) {
28153 int _v;
28154 {
28155 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28156 }
28157 if (_v) {
28158 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28159 }
28160 }
28161 if (argc == 1) {
28162 int _v;
28163 {
28164 void *ptr = 0;
28165 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28166 _v = 0;
28167 PyErr_Clear();
28168 } else {
28169 _v = (ptr != 0);
28170 }
28171 }
28172 if (_v) {
28173 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28174 }
28175 }
28176
28177 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28178 return NULL;
28179 }
28180
28181
28182 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28183 PyObject *resultobj;
28184 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28185 PyObject *arg2 = (PyObject *) 0 ;
28186 bool result;
28187 PyObject * obj0 = 0 ;
28188 PyObject * obj1 = 0 ;
28189 char *kwnames[] = {
28190 (char *) "self",(char *) "data", NULL
28191 };
28192
28193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28195 if (SWIG_arg_fail(1)) SWIG_fail;
28196 arg2 = obj1;
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28200
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 {
28205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28206 }
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28214 PyObject *resultobj;
28215 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28216 size_t result;
28217 PyObject * obj0 = 0 ;
28218 char *kwnames[] = {
28219 (char *) "self", NULL
28220 };
28221
28222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28224 if (SWIG_arg_fail(1)) SWIG_fail;
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 result = (size_t)(arg1)->GetSize();
28228
28229 wxPyEndAllowThreads(__tstate);
28230 if (PyErr_Occurred()) SWIG_fail;
28231 }
28232 {
28233 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28234 }
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28242 PyObject *resultobj;
28243 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28244 PyObject *result;
28245 PyObject * obj0 = 0 ;
28246 char *kwnames[] = {
28247 (char *) "self", NULL
28248 };
28249
28250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28252 if (SWIG_arg_fail(1)) SWIG_fail;
28253 {
28254 PyThreadState* __tstate = wxPyBeginAllowThreads();
28255 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28256
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 resultobj = result;
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28268 PyObject *obj;
28269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28270 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28271 Py_INCREF(obj);
28272 return Py_BuildValue((char *)"");
28273 }
28274 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj;
28276 wxURLDataObject *result;
28277 char *kwnames[] = {
28278 NULL
28279 };
28280
28281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 result = (wxURLDataObject *)new wxURLDataObject();
28285
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj;
28298 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28299 wxString result;
28300 PyObject * obj0 = 0 ;
28301 char *kwnames[] = {
28302 (char *) "self", NULL
28303 };
28304
28305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28307 if (SWIG_arg_fail(1)) SWIG_fail;
28308 {
28309 PyThreadState* __tstate = wxPyBeginAllowThreads();
28310 result = (arg1)->GetURL();
28311
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 {
28316 #if wxUSE_UNICODE
28317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28318 #else
28319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28320 #endif
28321 }
28322 return resultobj;
28323 fail:
28324 return NULL;
28325 }
28326
28327
28328 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28329 PyObject *resultobj;
28330 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28331 wxString *arg2 = 0 ;
28332 bool temp2 = false ;
28333 PyObject * obj0 = 0 ;
28334 PyObject * obj1 = 0 ;
28335 char *kwnames[] = {
28336 (char *) "self",(char *) "url", NULL
28337 };
28338
28339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28341 if (SWIG_arg_fail(1)) SWIG_fail;
28342 {
28343 arg2 = wxString_in_helper(obj1);
28344 if (arg2 == NULL) SWIG_fail;
28345 temp2 = true;
28346 }
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 (arg1)->SetURL((wxString const &)*arg2);
28350
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 Py_INCREF(Py_None); resultobj = Py_None;
28355 {
28356 if (temp2)
28357 delete arg2;
28358 }
28359 return resultobj;
28360 fail:
28361 {
28362 if (temp2)
28363 delete arg2;
28364 }
28365 return NULL;
28366 }
28367
28368
28369 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28370 PyObject *obj;
28371 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28372 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28373 Py_INCREF(obj);
28374 return Py_BuildValue((char *)"");
28375 }
28376 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28377 PyObject *resultobj;
28378 wxMetafileDataObject *result;
28379 char *kwnames[] = {
28380 NULL
28381 };
28382
28383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28387
28388 wxPyEndAllowThreads(__tstate);
28389 if (PyErr_Occurred()) SWIG_fail;
28390 }
28391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj;
28400 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28401 wxMetafile *arg2 = 0 ;
28402 PyObject * obj0 = 0 ;
28403 PyObject * obj1 = 0 ;
28404 char *kwnames[] = {
28405 (char *) "self",(char *) "metafile", NULL
28406 };
28407
28408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28410 if (SWIG_arg_fail(1)) SWIG_fail;
28411 {
28412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28413 if (SWIG_arg_fail(2)) SWIG_fail;
28414 if (arg2 == NULL) {
28415 SWIG_null_ref("wxMetafile");
28416 }
28417 if (SWIG_arg_fail(2)) SWIG_fail;
28418 }
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28422
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 Py_INCREF(Py_None); resultobj = Py_None;
28427 return resultobj;
28428 fail:
28429 return NULL;
28430 }
28431
28432
28433 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28434 PyObject *resultobj;
28435 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28436 wxMetafile result;
28437 PyObject * obj0 = 0 ;
28438 char *kwnames[] = {
28439 (char *) "self", NULL
28440 };
28441
28442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28444 if (SWIG_arg_fail(1)) SWIG_fail;
28445 {
28446 PyThreadState* __tstate = wxPyBeginAllowThreads();
28447 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28448
28449 wxPyEndAllowThreads(__tstate);
28450 if (PyErr_Occurred()) SWIG_fail;
28451 }
28452 {
28453 wxMetafile * resultptr;
28454 resultptr = new wxMetafile((wxMetafile &)(result));
28455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28456 }
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28464 PyObject *obj;
28465 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28466 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28467 Py_INCREF(obj);
28468 return Py_BuildValue((char *)"");
28469 }
28470 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28471 PyObject *resultobj;
28472 wxDragResult arg1 ;
28473 bool result;
28474 PyObject * obj0 = 0 ;
28475 char *kwnames[] = {
28476 (char *) "res", NULL
28477 };
28478
28479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28480 {
28481 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28482 if (SWIG_arg_fail(1)) SWIG_fail;
28483 }
28484 {
28485 PyThreadState* __tstate = wxPyBeginAllowThreads();
28486 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28487
28488 wxPyEndAllowThreads(__tstate);
28489 if (PyErr_Occurred()) SWIG_fail;
28490 }
28491 {
28492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28493 }
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28501 PyObject *resultobj;
28502 wxWindow *arg1 = (wxWindow *) 0 ;
28503 wxCursor const &arg2_defvalue = wxNullCursor ;
28504 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28505 wxCursor const &arg3_defvalue = wxNullCursor ;
28506 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28507 wxCursor const &arg4_defvalue = wxNullCursor ;
28508 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28509 wxPyDropSource *result;
28510 PyObject * obj0 = 0 ;
28511 PyObject * obj1 = 0 ;
28512 PyObject * obj2 = 0 ;
28513 PyObject * obj3 = 0 ;
28514 char *kwnames[] = {
28515 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28516 };
28517
28518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28520 if (SWIG_arg_fail(1)) SWIG_fail;
28521 if (obj1) {
28522 {
28523 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28524 if (SWIG_arg_fail(2)) SWIG_fail;
28525 if (arg2 == NULL) {
28526 SWIG_null_ref("wxCursor");
28527 }
28528 if (SWIG_arg_fail(2)) SWIG_fail;
28529 }
28530 }
28531 if (obj2) {
28532 {
28533 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28534 if (SWIG_arg_fail(3)) SWIG_fail;
28535 if (arg3 == NULL) {
28536 SWIG_null_ref("wxCursor");
28537 }
28538 if (SWIG_arg_fail(3)) SWIG_fail;
28539 }
28540 }
28541 if (obj3) {
28542 {
28543 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28544 if (SWIG_arg_fail(4)) SWIG_fail;
28545 if (arg4 == NULL) {
28546 SWIG_null_ref("wxCursor");
28547 }
28548 if (SWIG_arg_fail(4)) SWIG_fail;
28549 }
28550 }
28551 {
28552 PyThreadState* __tstate = wxPyBeginAllowThreads();
28553 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28554
28555 wxPyEndAllowThreads(__tstate);
28556 if (PyErr_Occurred()) SWIG_fail;
28557 }
28558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28559 return resultobj;
28560 fail:
28561 return NULL;
28562 }
28563
28564
28565 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28566 PyObject *resultobj;
28567 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28568 PyObject *arg2 = (PyObject *) 0 ;
28569 PyObject *arg3 = (PyObject *) 0 ;
28570 int arg4 ;
28571 PyObject * obj0 = 0 ;
28572 PyObject * obj1 = 0 ;
28573 PyObject * obj2 = 0 ;
28574 PyObject * obj3 = 0 ;
28575 char *kwnames[] = {
28576 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28577 };
28578
28579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(1)) SWIG_fail;
28582 arg2 = obj1;
28583 arg3 = obj2;
28584 {
28585 arg4 = (int)(SWIG_As_int(obj3));
28586 if (SWIG_arg_fail(4)) SWIG_fail;
28587 }
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28591
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 Py_INCREF(Py_None); resultobj = Py_None;
28596 return resultobj;
28597 fail:
28598 return NULL;
28599 }
28600
28601
28602 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28603 PyObject *resultobj;
28604 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28605 PyObject * obj0 = 0 ;
28606 char *kwnames[] = {
28607 (char *) "self", NULL
28608 };
28609
28610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28612 if (SWIG_arg_fail(1)) SWIG_fail;
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 delete arg1;
28616
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 Py_INCREF(Py_None); resultobj = Py_None;
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28628 PyObject *resultobj;
28629 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28630 wxDataObject *arg2 = 0 ;
28631 PyObject * obj0 = 0 ;
28632 PyObject * obj1 = 0 ;
28633 char *kwnames[] = {
28634 (char *) "self",(char *) "data", NULL
28635 };
28636
28637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28639 if (SWIG_arg_fail(1)) SWIG_fail;
28640 {
28641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28642 if (SWIG_arg_fail(2)) SWIG_fail;
28643 if (arg2 == NULL) {
28644 SWIG_null_ref("wxDataObject");
28645 }
28646 if (SWIG_arg_fail(2)) SWIG_fail;
28647 }
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 (arg1)->SetData(*arg2);
28651
28652 wxPyEndAllowThreads(__tstate);
28653 if (PyErr_Occurred()) SWIG_fail;
28654 }
28655 Py_INCREF(Py_None); resultobj = Py_None;
28656 return resultobj;
28657 fail:
28658 return NULL;
28659 }
28660
28661
28662 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28663 PyObject *resultobj;
28664 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28665 wxDataObject *result;
28666 PyObject * obj0 = 0 ;
28667 char *kwnames[] = {
28668 (char *) "self", NULL
28669 };
28670
28671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28673 if (SWIG_arg_fail(1)) SWIG_fail;
28674 {
28675 PyThreadState* __tstate = wxPyBeginAllowThreads();
28676 result = (wxDataObject *)(arg1)->GetDataObject();
28677
28678 wxPyEndAllowThreads(__tstate);
28679 if (PyErr_Occurred()) SWIG_fail;
28680 }
28681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28682 return resultobj;
28683 fail:
28684 return NULL;
28685 }
28686
28687
28688 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28689 PyObject *resultobj;
28690 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28691 wxDragResult arg2 ;
28692 wxCursor *arg3 = 0 ;
28693 PyObject * obj0 = 0 ;
28694 PyObject * obj1 = 0 ;
28695 PyObject * obj2 = 0 ;
28696 char *kwnames[] = {
28697 (char *) "self",(char *) "res",(char *) "cursor", NULL
28698 };
28699
28700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28702 if (SWIG_arg_fail(1)) SWIG_fail;
28703 {
28704 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28705 if (SWIG_arg_fail(2)) SWIG_fail;
28706 }
28707 {
28708 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28709 if (SWIG_arg_fail(3)) SWIG_fail;
28710 if (arg3 == NULL) {
28711 SWIG_null_ref("wxCursor");
28712 }
28713 if (SWIG_arg_fail(3)) SWIG_fail;
28714 }
28715 {
28716 PyThreadState* __tstate = wxPyBeginAllowThreads();
28717 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28718
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 Py_INCREF(Py_None); resultobj = Py_None;
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj;
28731 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28732 int arg2 = (int) wxDrag_CopyOnly ;
28733 wxDragResult result;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 char *kwnames[] = {
28737 (char *) "self",(char *) "flags", NULL
28738 };
28739
28740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28742 if (SWIG_arg_fail(1)) SWIG_fail;
28743 if (obj1) {
28744 {
28745 arg2 = (int)(SWIG_As_int(obj1));
28746 if (SWIG_arg_fail(2)) SWIG_fail;
28747 }
28748 }
28749 {
28750 PyThreadState* __tstate = wxPyBeginAllowThreads();
28751 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28752
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_From_int((result));
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj;
28765 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28766 wxDragResult arg2 ;
28767 bool result;
28768 PyObject * obj0 = 0 ;
28769 PyObject * obj1 = 0 ;
28770 char *kwnames[] = {
28771 (char *) "self",(char *) "effect", NULL
28772 };
28773
28774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28776 if (SWIG_arg_fail(1)) SWIG_fail;
28777 {
28778 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28779 if (SWIG_arg_fail(2)) SWIG_fail;
28780 }
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28784
28785 wxPyEndAllowThreads(__tstate);
28786 if (PyErr_Occurred()) SWIG_fail;
28787 }
28788 {
28789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28790 }
28791 return resultobj;
28792 fail:
28793 return NULL;
28794 }
28795
28796
28797 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28798 PyObject *obj;
28799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28800 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28801 Py_INCREF(obj);
28802 return Py_BuildValue((char *)"");
28803 }
28804 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28805 PyObject *resultobj;
28806 wxDataObject *arg1 = (wxDataObject *) NULL ;
28807 wxPyDropTarget *result;
28808 PyObject * obj0 = 0 ;
28809 char *kwnames[] = {
28810 (char *) "dataObject", NULL
28811 };
28812
28813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28814 if (obj0) {
28815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28816 if (SWIG_arg_fail(1)) SWIG_fail;
28817 }
28818 {
28819 PyThreadState* __tstate = wxPyBeginAllowThreads();
28820 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28821
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28833 PyObject *resultobj;
28834 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28835 PyObject *arg2 = (PyObject *) 0 ;
28836 PyObject *arg3 = (PyObject *) 0 ;
28837 PyObject * obj0 = 0 ;
28838 PyObject * obj1 = 0 ;
28839 PyObject * obj2 = 0 ;
28840 char *kwnames[] = {
28841 (char *) "self",(char *) "self",(char *) "_class", NULL
28842 };
28843
28844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28846 if (SWIG_arg_fail(1)) SWIG_fail;
28847 arg2 = obj1;
28848 arg3 = obj2;
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 (arg1)->_setCallbackInfo(arg2,arg3);
28852
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 Py_INCREF(Py_None); resultobj = Py_None;
28857 return resultobj;
28858 fail:
28859 return NULL;
28860 }
28861
28862
28863 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28864 PyObject *resultobj;
28865 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28866 PyObject * obj0 = 0 ;
28867 char *kwnames[] = {
28868 (char *) "self", NULL
28869 };
28870
28871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28873 if (SWIG_arg_fail(1)) SWIG_fail;
28874 {
28875 PyThreadState* __tstate = wxPyBeginAllowThreads();
28876 delete arg1;
28877
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 Py_INCREF(Py_None); resultobj = Py_None;
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28889 PyObject *resultobj;
28890 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28891 wxDataObject *result;
28892 PyObject * obj0 = 0 ;
28893 char *kwnames[] = {
28894 (char *) "self", NULL
28895 };
28896
28897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28899 if (SWIG_arg_fail(1)) SWIG_fail;
28900 {
28901 PyThreadState* __tstate = wxPyBeginAllowThreads();
28902 result = (wxDataObject *)(arg1)->GetDataObject();
28903
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28908 return resultobj;
28909 fail:
28910 return NULL;
28911 }
28912
28913
28914 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28915 PyObject *resultobj;
28916 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28917 wxDataObject *arg2 = (wxDataObject *) 0 ;
28918 PyObject * obj0 = 0 ;
28919 PyObject * obj1 = 0 ;
28920 char *kwnames[] = {
28921 (char *) "self",(char *) "dataObject", NULL
28922 };
28923
28924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28926 if (SWIG_arg_fail(1)) SWIG_fail;
28927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28928 if (SWIG_arg_fail(2)) SWIG_fail;
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 (arg1)->SetDataObject(arg2);
28932
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 Py_INCREF(Py_None); resultobj = Py_None;
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28944 PyObject *resultobj;
28945 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28946 int arg2 ;
28947 int arg3 ;
28948 wxDragResult arg4 ;
28949 wxDragResult result;
28950 PyObject * obj0 = 0 ;
28951 PyObject * obj1 = 0 ;
28952 PyObject * obj2 = 0 ;
28953 PyObject * obj3 = 0 ;
28954 char *kwnames[] = {
28955 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28956 };
28957
28958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28960 if (SWIG_arg_fail(1)) SWIG_fail;
28961 {
28962 arg2 = (int)(SWIG_As_int(obj1));
28963 if (SWIG_arg_fail(2)) SWIG_fail;
28964 }
28965 {
28966 arg3 = (int)(SWIG_As_int(obj2));
28967 if (SWIG_arg_fail(3)) SWIG_fail;
28968 }
28969 {
28970 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28971 if (SWIG_arg_fail(4)) SWIG_fail;
28972 }
28973 {
28974 PyThreadState* __tstate = wxPyBeginAllowThreads();
28975 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28976
28977 wxPyEndAllowThreads(__tstate);
28978 if (PyErr_Occurred()) SWIG_fail;
28979 }
28980 resultobj = SWIG_From_int((result));
28981 return resultobj;
28982 fail:
28983 return NULL;
28984 }
28985
28986
28987 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28988 PyObject *resultobj;
28989 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28990 int arg2 ;
28991 int arg3 ;
28992 wxDragResult arg4 ;
28993 wxDragResult result;
28994 PyObject * obj0 = 0 ;
28995 PyObject * obj1 = 0 ;
28996 PyObject * obj2 = 0 ;
28997 PyObject * obj3 = 0 ;
28998 char *kwnames[] = {
28999 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29000 };
29001
29002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29004 if (SWIG_arg_fail(1)) SWIG_fail;
29005 {
29006 arg2 = (int)(SWIG_As_int(obj1));
29007 if (SWIG_arg_fail(2)) SWIG_fail;
29008 }
29009 {
29010 arg3 = (int)(SWIG_As_int(obj2));
29011 if (SWIG_arg_fail(3)) SWIG_fail;
29012 }
29013 {
29014 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29015 if (SWIG_arg_fail(4)) SWIG_fail;
29016 }
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29020
29021 wxPyEndAllowThreads(__tstate);
29022 if (PyErr_Occurred()) SWIG_fail;
29023 }
29024 resultobj = SWIG_From_int((result));
29025 return resultobj;
29026 fail:
29027 return NULL;
29028 }
29029
29030
29031 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29032 PyObject *resultobj;
29033 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29034 PyObject * obj0 = 0 ;
29035 char *kwnames[] = {
29036 (char *) "self", NULL
29037 };
29038
29039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29041 if (SWIG_arg_fail(1)) SWIG_fail;
29042 {
29043 PyThreadState* __tstate = wxPyBeginAllowThreads();
29044 (arg1)->base_OnLeave();
29045
29046 wxPyEndAllowThreads(__tstate);
29047 if (PyErr_Occurred()) SWIG_fail;
29048 }
29049 Py_INCREF(Py_None); resultobj = Py_None;
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj;
29058 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29059 int arg2 ;
29060 int arg3 ;
29061 bool result;
29062 PyObject * obj0 = 0 ;
29063 PyObject * obj1 = 0 ;
29064 PyObject * obj2 = 0 ;
29065 char *kwnames[] = {
29066 (char *) "self",(char *) "x",(char *) "y", NULL
29067 };
29068
29069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29071 if (SWIG_arg_fail(1)) SWIG_fail;
29072 {
29073 arg2 = (int)(SWIG_As_int(obj1));
29074 if (SWIG_arg_fail(2)) SWIG_fail;
29075 }
29076 {
29077 arg3 = (int)(SWIG_As_int(obj2));
29078 if (SWIG_arg_fail(3)) SWIG_fail;
29079 }
29080 {
29081 PyThreadState* __tstate = wxPyBeginAllowThreads();
29082 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29083
29084 wxPyEndAllowThreads(__tstate);
29085 if (PyErr_Occurred()) SWIG_fail;
29086 }
29087 {
29088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29089 }
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29097 PyObject *resultobj;
29098 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29099 bool result;
29100 PyObject * obj0 = 0 ;
29101 char *kwnames[] = {
29102 (char *) "self", NULL
29103 };
29104
29105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29107 if (SWIG_arg_fail(1)) SWIG_fail;
29108 {
29109 PyThreadState* __tstate = wxPyBeginAllowThreads();
29110 result = (bool)(arg1)->GetData();
29111
29112 wxPyEndAllowThreads(__tstate);
29113 if (PyErr_Occurred()) SWIG_fail;
29114 }
29115 {
29116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29117 }
29118 return resultobj;
29119 fail:
29120 return NULL;
29121 }
29122
29123
29124 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29125 PyObject *obj;
29126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29127 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29128 Py_INCREF(obj);
29129 return Py_BuildValue((char *)"");
29130 }
29131 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29132 PyObject *resultobj;
29133 wxPyTextDropTarget *result;
29134 char *kwnames[] = {
29135 NULL
29136 };
29137
29138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29139 {
29140 PyThreadState* __tstate = wxPyBeginAllowThreads();
29141 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29142
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29147 return resultobj;
29148 fail:
29149 return NULL;
29150 }
29151
29152
29153 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj;
29155 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29156 PyObject *arg2 = (PyObject *) 0 ;
29157 PyObject *arg3 = (PyObject *) 0 ;
29158 PyObject * obj0 = 0 ;
29159 PyObject * obj1 = 0 ;
29160 PyObject * obj2 = 0 ;
29161 char *kwnames[] = {
29162 (char *) "self",(char *) "self",(char *) "_class", NULL
29163 };
29164
29165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29167 if (SWIG_arg_fail(1)) SWIG_fail;
29168 arg2 = obj1;
29169 arg3 = obj2;
29170 {
29171 PyThreadState* __tstate = wxPyBeginAllowThreads();
29172 (arg1)->_setCallbackInfo(arg2,arg3);
29173
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 Py_INCREF(Py_None); resultobj = Py_None;
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29185 PyObject *resultobj;
29186 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29187 int arg2 ;
29188 int arg3 ;
29189 wxDragResult arg4 ;
29190 wxDragResult result;
29191 PyObject * obj0 = 0 ;
29192 PyObject * obj1 = 0 ;
29193 PyObject * obj2 = 0 ;
29194 PyObject * obj3 = 0 ;
29195 char *kwnames[] = {
29196 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29197 };
29198
29199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29201 if (SWIG_arg_fail(1)) SWIG_fail;
29202 {
29203 arg2 = (int)(SWIG_As_int(obj1));
29204 if (SWIG_arg_fail(2)) SWIG_fail;
29205 }
29206 {
29207 arg3 = (int)(SWIG_As_int(obj2));
29208 if (SWIG_arg_fail(3)) SWIG_fail;
29209 }
29210 {
29211 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29212 if (SWIG_arg_fail(4)) SWIG_fail;
29213 }
29214 {
29215 PyThreadState* __tstate = wxPyBeginAllowThreads();
29216 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29217
29218 wxPyEndAllowThreads(__tstate);
29219 if (PyErr_Occurred()) SWIG_fail;
29220 }
29221 resultobj = SWIG_From_int((result));
29222 return resultobj;
29223 fail:
29224 return NULL;
29225 }
29226
29227
29228 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj;
29230 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29231 int arg2 ;
29232 int arg3 ;
29233 wxDragResult arg4 ;
29234 wxDragResult result;
29235 PyObject * obj0 = 0 ;
29236 PyObject * obj1 = 0 ;
29237 PyObject * obj2 = 0 ;
29238 PyObject * obj3 = 0 ;
29239 char *kwnames[] = {
29240 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29241 };
29242
29243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
29247 arg2 = (int)(SWIG_As_int(obj1));
29248 if (SWIG_arg_fail(2)) SWIG_fail;
29249 }
29250 {
29251 arg3 = (int)(SWIG_As_int(obj2));
29252 if (SWIG_arg_fail(3)) SWIG_fail;
29253 }
29254 {
29255 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29256 if (SWIG_arg_fail(4)) SWIG_fail;
29257 }
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 resultobj = SWIG_From_int((result));
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29273 PyObject *resultobj;
29274 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29275 PyObject * obj0 = 0 ;
29276 char *kwnames[] = {
29277 (char *) "self", NULL
29278 };
29279
29280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29282 if (SWIG_arg_fail(1)) SWIG_fail;
29283 {
29284 PyThreadState* __tstate = wxPyBeginAllowThreads();
29285 (arg1)->base_OnLeave();
29286
29287 wxPyEndAllowThreads(__tstate);
29288 if (PyErr_Occurred()) SWIG_fail;
29289 }
29290 Py_INCREF(Py_None); resultobj = Py_None;
29291 return resultobj;
29292 fail:
29293 return NULL;
29294 }
29295
29296
29297 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29298 PyObject *resultobj;
29299 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29300 int arg2 ;
29301 int arg3 ;
29302 bool result;
29303 PyObject * obj0 = 0 ;
29304 PyObject * obj1 = 0 ;
29305 PyObject * obj2 = 0 ;
29306 char *kwnames[] = {
29307 (char *) "self",(char *) "x",(char *) "y", NULL
29308 };
29309
29310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(1)) SWIG_fail;
29313 {
29314 arg2 = (int)(SWIG_As_int(obj1));
29315 if (SWIG_arg_fail(2)) SWIG_fail;
29316 }
29317 {
29318 arg3 = (int)(SWIG_As_int(obj2));
29319 if (SWIG_arg_fail(3)) SWIG_fail;
29320 }
29321 {
29322 PyThreadState* __tstate = wxPyBeginAllowThreads();
29323 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29324
29325 wxPyEndAllowThreads(__tstate);
29326 if (PyErr_Occurred()) SWIG_fail;
29327 }
29328 {
29329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29330 }
29331 return resultobj;
29332 fail:
29333 return NULL;
29334 }
29335
29336
29337 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29338 PyObject *resultobj;
29339 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29340 int arg2 ;
29341 int arg3 ;
29342 wxDragResult arg4 ;
29343 wxDragResult result;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 PyObject * obj2 = 0 ;
29347 PyObject * obj3 = 0 ;
29348 char *kwnames[] = {
29349 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29350 };
29351
29352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29354 if (SWIG_arg_fail(1)) SWIG_fail;
29355 {
29356 arg2 = (int)(SWIG_As_int(obj1));
29357 if (SWIG_arg_fail(2)) SWIG_fail;
29358 }
29359 {
29360 arg3 = (int)(SWIG_As_int(obj2));
29361 if (SWIG_arg_fail(3)) SWIG_fail;
29362 }
29363 {
29364 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29365 if (SWIG_arg_fail(4)) SWIG_fail;
29366 }
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29370
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 resultobj = SWIG_From_int((result));
29375 return resultobj;
29376 fail:
29377 return NULL;
29378 }
29379
29380
29381 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29382 PyObject *obj;
29383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29384 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29385 Py_INCREF(obj);
29386 return Py_BuildValue((char *)"");
29387 }
29388 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29389 PyObject *resultobj;
29390 wxPyFileDropTarget *result;
29391 char *kwnames[] = {
29392 NULL
29393 };
29394
29395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29396 {
29397 PyThreadState* __tstate = wxPyBeginAllowThreads();
29398 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29399
29400 wxPyEndAllowThreads(__tstate);
29401 if (PyErr_Occurred()) SWIG_fail;
29402 }
29403 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29404 return resultobj;
29405 fail:
29406 return NULL;
29407 }
29408
29409
29410 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29411 PyObject *resultobj;
29412 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29413 PyObject *arg2 = (PyObject *) 0 ;
29414 PyObject *arg3 = (PyObject *) 0 ;
29415 PyObject * obj0 = 0 ;
29416 PyObject * obj1 = 0 ;
29417 PyObject * obj2 = 0 ;
29418 char *kwnames[] = {
29419 (char *) "self",(char *) "self",(char *) "_class", NULL
29420 };
29421
29422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29424 if (SWIG_arg_fail(1)) SWIG_fail;
29425 arg2 = obj1;
29426 arg3 = obj2;
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 (arg1)->_setCallbackInfo(arg2,arg3);
29430
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 Py_INCREF(Py_None); resultobj = Py_None;
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj;
29443 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29444 int arg2 ;
29445 int arg3 ;
29446 wxDragResult arg4 ;
29447 wxDragResult result;
29448 PyObject * obj0 = 0 ;
29449 PyObject * obj1 = 0 ;
29450 PyObject * obj2 = 0 ;
29451 PyObject * obj3 = 0 ;
29452 char *kwnames[] = {
29453 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29454 };
29455
29456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29458 if (SWIG_arg_fail(1)) SWIG_fail;
29459 {
29460 arg2 = (int)(SWIG_As_int(obj1));
29461 if (SWIG_arg_fail(2)) SWIG_fail;
29462 }
29463 {
29464 arg3 = (int)(SWIG_As_int(obj2));
29465 if (SWIG_arg_fail(3)) SWIG_fail;
29466 }
29467 {
29468 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29469 if (SWIG_arg_fail(4)) SWIG_fail;
29470 }
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29474
29475 wxPyEndAllowThreads(__tstate);
29476 if (PyErr_Occurred()) SWIG_fail;
29477 }
29478 resultobj = SWIG_From_int((result));
29479 return resultobj;
29480 fail:
29481 return NULL;
29482 }
29483
29484
29485 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29486 PyObject *resultobj;
29487 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29488 int arg2 ;
29489 int arg3 ;
29490 wxDragResult arg4 ;
29491 wxDragResult result;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 PyObject * obj2 = 0 ;
29495 PyObject * obj3 = 0 ;
29496 char *kwnames[] = {
29497 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29498 };
29499
29500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) 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 {
29504 arg2 = (int)(SWIG_As_int(obj1));
29505 if (SWIG_arg_fail(2)) SWIG_fail;
29506 }
29507 {
29508 arg3 = (int)(SWIG_As_int(obj2));
29509 if (SWIG_arg_fail(3)) SWIG_fail;
29510 }
29511 {
29512 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29513 if (SWIG_arg_fail(4)) SWIG_fail;
29514 }
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29518
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 resultobj = SWIG_From_int((result));
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj;
29531 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29532 PyObject * obj0 = 0 ;
29533 char *kwnames[] = {
29534 (char *) "self", NULL
29535 };
29536
29537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29539 if (SWIG_arg_fail(1)) SWIG_fail;
29540 {
29541 PyThreadState* __tstate = wxPyBeginAllowThreads();
29542 (arg1)->base_OnLeave();
29543
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 Py_INCREF(Py_None); resultobj = Py_None;
29548 return resultobj;
29549 fail:
29550 return NULL;
29551 }
29552
29553
29554 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29555 PyObject *resultobj;
29556 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29557 int arg2 ;
29558 int arg3 ;
29559 bool result;
29560 PyObject * obj0 = 0 ;
29561 PyObject * obj1 = 0 ;
29562 PyObject * obj2 = 0 ;
29563 char *kwnames[] = {
29564 (char *) "self",(char *) "x",(char *) "y", NULL
29565 };
29566
29567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29569 if (SWIG_arg_fail(1)) SWIG_fail;
29570 {
29571 arg2 = (int)(SWIG_As_int(obj1));
29572 if (SWIG_arg_fail(2)) SWIG_fail;
29573 }
29574 {
29575 arg3 = (int)(SWIG_As_int(obj2));
29576 if (SWIG_arg_fail(3)) SWIG_fail;
29577 }
29578 {
29579 PyThreadState* __tstate = wxPyBeginAllowThreads();
29580 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29581
29582 wxPyEndAllowThreads(__tstate);
29583 if (PyErr_Occurred()) SWIG_fail;
29584 }
29585 {
29586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29587 }
29588 return resultobj;
29589 fail:
29590 return NULL;
29591 }
29592
29593
29594 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29595 PyObject *resultobj;
29596 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29597 int arg2 ;
29598 int arg3 ;
29599 wxDragResult arg4 ;
29600 wxDragResult result;
29601 PyObject * obj0 = 0 ;
29602 PyObject * obj1 = 0 ;
29603 PyObject * obj2 = 0 ;
29604 PyObject * obj3 = 0 ;
29605 char *kwnames[] = {
29606 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29607 };
29608
29609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29611 if (SWIG_arg_fail(1)) SWIG_fail;
29612 {
29613 arg2 = (int)(SWIG_As_int(obj1));
29614 if (SWIG_arg_fail(2)) SWIG_fail;
29615 }
29616 {
29617 arg3 = (int)(SWIG_As_int(obj2));
29618 if (SWIG_arg_fail(3)) SWIG_fail;
29619 }
29620 {
29621 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29622 if (SWIG_arg_fail(4)) SWIG_fail;
29623 }
29624 {
29625 PyThreadState* __tstate = wxPyBeginAllowThreads();
29626 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29627
29628 wxPyEndAllowThreads(__tstate);
29629 if (PyErr_Occurred()) SWIG_fail;
29630 }
29631 resultobj = SWIG_From_int((result));
29632 return resultobj;
29633 fail:
29634 return NULL;
29635 }
29636
29637
29638 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29639 PyObject *obj;
29640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29641 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29642 Py_INCREF(obj);
29643 return Py_BuildValue((char *)"");
29644 }
29645 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29646 PyObject *resultobj;
29647 wxClipboard *result;
29648 char *kwnames[] = {
29649 NULL
29650 };
29651
29652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29653 {
29654 PyThreadState* __tstate = wxPyBeginAllowThreads();
29655 result = (wxClipboard *)new wxClipboard();
29656
29657 wxPyEndAllowThreads(__tstate);
29658 if (PyErr_Occurred()) SWIG_fail;
29659 }
29660 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29668 PyObject *resultobj;
29669 wxClipboard *arg1 = (wxClipboard *) 0 ;
29670 PyObject * obj0 = 0 ;
29671 char *kwnames[] = {
29672 (char *) "self", NULL
29673 };
29674
29675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29677 if (SWIG_arg_fail(1)) SWIG_fail;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 delete arg1;
29681
29682 wxPyEndAllowThreads(__tstate);
29683 if (PyErr_Occurred()) SWIG_fail;
29684 }
29685 Py_INCREF(Py_None); resultobj = Py_None;
29686 return resultobj;
29687 fail:
29688 return NULL;
29689 }
29690
29691
29692 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29693 PyObject *resultobj;
29694 wxClipboard *arg1 = (wxClipboard *) 0 ;
29695 bool result;
29696 PyObject * obj0 = 0 ;
29697 char *kwnames[] = {
29698 (char *) "self", NULL
29699 };
29700
29701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29703 if (SWIG_arg_fail(1)) SWIG_fail;
29704 {
29705 PyThreadState* __tstate = wxPyBeginAllowThreads();
29706 result = (bool)(arg1)->Open();
29707
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 {
29712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29713 }
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29721 PyObject *resultobj;
29722 wxClipboard *arg1 = (wxClipboard *) 0 ;
29723 PyObject * obj0 = 0 ;
29724 char *kwnames[] = {
29725 (char *) "self", NULL
29726 };
29727
29728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29730 if (SWIG_arg_fail(1)) SWIG_fail;
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 (arg1)->Close();
29734
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 Py_INCREF(Py_None); resultobj = Py_None;
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29746 PyObject *resultobj;
29747 wxClipboard *arg1 = (wxClipboard *) 0 ;
29748 bool result;
29749 PyObject * obj0 = 0 ;
29750 char *kwnames[] = {
29751 (char *) "self", NULL
29752 };
29753
29754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29756 if (SWIG_arg_fail(1)) SWIG_fail;
29757 {
29758 PyThreadState* __tstate = wxPyBeginAllowThreads();
29759 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29760
29761 wxPyEndAllowThreads(__tstate);
29762 if (PyErr_Occurred()) SWIG_fail;
29763 }
29764 {
29765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29766 }
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29774 PyObject *resultobj;
29775 wxClipboard *arg1 = (wxClipboard *) 0 ;
29776 wxDataObject *arg2 = (wxDataObject *) 0 ;
29777 bool result;
29778 PyObject * obj0 = 0 ;
29779 PyObject * obj1 = 0 ;
29780 char *kwnames[] = {
29781 (char *) "self",(char *) "data", NULL
29782 };
29783
29784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29786 if (SWIG_arg_fail(1)) SWIG_fail;
29787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29788 if (SWIG_arg_fail(2)) SWIG_fail;
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 result = (bool)(arg1)->AddData(arg2);
29792
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 {
29797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29798 }
29799 return resultobj;
29800 fail:
29801 return NULL;
29802 }
29803
29804
29805 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29806 PyObject *resultobj;
29807 wxClipboard *arg1 = (wxClipboard *) 0 ;
29808 wxDataObject *arg2 = (wxDataObject *) 0 ;
29809 bool result;
29810 PyObject * obj0 = 0 ;
29811 PyObject * obj1 = 0 ;
29812 char *kwnames[] = {
29813 (char *) "self",(char *) "data", NULL
29814 };
29815
29816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29818 if (SWIG_arg_fail(1)) SWIG_fail;
29819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29820 if (SWIG_arg_fail(2)) SWIG_fail;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = (bool)(arg1)->SetData(arg2);
29824
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 {
29829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29830 }
29831 return resultobj;
29832 fail:
29833 return NULL;
29834 }
29835
29836
29837 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxClipboard *arg1 = (wxClipboard *) 0 ;
29840 wxDataFormat *arg2 = 0 ;
29841 bool result;
29842 PyObject * obj0 = 0 ;
29843 PyObject * obj1 = 0 ;
29844 char *kwnames[] = {
29845 (char *) "self",(char *) "format", NULL
29846 };
29847
29848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29850 if (SWIG_arg_fail(1)) SWIG_fail;
29851 {
29852 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29853 if (SWIG_arg_fail(2)) SWIG_fail;
29854 if (arg2 == NULL) {
29855 SWIG_null_ref("wxDataFormat");
29856 }
29857 if (SWIG_arg_fail(2)) SWIG_fail;
29858 }
29859 {
29860 PyThreadState* __tstate = wxPyBeginAllowThreads();
29861 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29862
29863 wxPyEndAllowThreads(__tstate);
29864 if (PyErr_Occurred()) SWIG_fail;
29865 }
29866 {
29867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj;
29877 wxClipboard *arg1 = (wxClipboard *) 0 ;
29878 wxDataObject *arg2 = 0 ;
29879 bool result;
29880 PyObject * obj0 = 0 ;
29881 PyObject * obj1 = 0 ;
29882 char *kwnames[] = {
29883 (char *) "self",(char *) "data", NULL
29884 };
29885
29886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29888 if (SWIG_arg_fail(1)) SWIG_fail;
29889 {
29890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29891 if (SWIG_arg_fail(2)) SWIG_fail;
29892 if (arg2 == NULL) {
29893 SWIG_null_ref("wxDataObject");
29894 }
29895 if (SWIG_arg_fail(2)) SWIG_fail;
29896 }
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (bool)(arg1)->GetData(*arg2);
29900
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 {
29905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29906 }
29907 return resultobj;
29908 fail:
29909 return NULL;
29910 }
29911
29912
29913 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29914 PyObject *resultobj;
29915 wxClipboard *arg1 = (wxClipboard *) 0 ;
29916 PyObject * obj0 = 0 ;
29917 char *kwnames[] = {
29918 (char *) "self", NULL
29919 };
29920
29921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29923 if (SWIG_arg_fail(1)) SWIG_fail;
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 (arg1)->Clear();
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 Py_INCREF(Py_None); resultobj = Py_None;
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj;
29940 wxClipboard *arg1 = (wxClipboard *) 0 ;
29941 bool result;
29942 PyObject * obj0 = 0 ;
29943 char *kwnames[] = {
29944 (char *) "self", NULL
29945 };
29946
29947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29949 if (SWIG_arg_fail(1)) SWIG_fail;
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 result = (bool)(arg1)->Flush();
29953
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 {
29958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29959 }
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj;
29968 wxClipboard *arg1 = (wxClipboard *) 0 ;
29969 bool arg2 = (bool) true ;
29970 PyObject * obj0 = 0 ;
29971 PyObject * obj1 = 0 ;
29972 char *kwnames[] = {
29973 (char *) "self",(char *) "primary", NULL
29974 };
29975
29976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29978 if (SWIG_arg_fail(1)) SWIG_fail;
29979 if (obj1) {
29980 {
29981 arg2 = (bool)(SWIG_As_bool(obj1));
29982 if (SWIG_arg_fail(2)) SWIG_fail;
29983 }
29984 }
29985 {
29986 PyThreadState* __tstate = wxPyBeginAllowThreads();
29987 (arg1)->UsePrimarySelection(arg2);
29988
29989 wxPyEndAllowThreads(__tstate);
29990 if (PyErr_Occurred()) SWIG_fail;
29991 }
29992 Py_INCREF(Py_None); resultobj = Py_None;
29993 return resultobj;
29994 fail:
29995 return NULL;
29996 }
29997
29998
29999 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30000 PyObject *resultobj;
30001 wxClipboard *result;
30002 char *kwnames[] = {
30003 NULL
30004 };
30005
30006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30007 {
30008 PyThreadState* __tstate = wxPyBeginAllowThreads();
30009 result = (wxClipboard *)wxClipboard::Get();
30010
30011 wxPyEndAllowThreads(__tstate);
30012 if (PyErr_Occurred()) SWIG_fail;
30013 }
30014 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30015 return resultobj;
30016 fail:
30017 return NULL;
30018 }
30019
30020
30021 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30022 PyObject *obj;
30023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30024 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30025 Py_INCREF(obj);
30026 return Py_BuildValue((char *)"");
30027 }
30028 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30029 PyObject *resultobj;
30030 wxClipboard *arg1 = (wxClipboard *) NULL ;
30031 wxClipboardLocker *result;
30032 PyObject * obj0 = 0 ;
30033 char *kwnames[] = {
30034 (char *) "clipboard", NULL
30035 };
30036
30037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30038 if (obj0) {
30039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30040 if (SWIG_arg_fail(1)) SWIG_fail;
30041 }
30042 {
30043 PyThreadState* __tstate = wxPyBeginAllowThreads();
30044 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30045
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30057 PyObject *resultobj;
30058 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30059 PyObject * obj0 = 0 ;
30060 char *kwnames[] = {
30061 (char *) "self", NULL
30062 };
30063
30064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30066 if (SWIG_arg_fail(1)) SWIG_fail;
30067 {
30068 PyThreadState* __tstate = wxPyBeginAllowThreads();
30069 delete arg1;
30070
30071 wxPyEndAllowThreads(__tstate);
30072 if (PyErr_Occurred()) SWIG_fail;
30073 }
30074 Py_INCREF(Py_None); resultobj = Py_None;
30075 return resultobj;
30076 fail:
30077 return NULL;
30078 }
30079
30080
30081 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30082 PyObject *resultobj;
30083 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30084 bool result;
30085 PyObject * obj0 = 0 ;
30086 char *kwnames[] = {
30087 (char *) "self", NULL
30088 };
30089
30090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30092 if (SWIG_arg_fail(1)) SWIG_fail;
30093 {
30094 PyThreadState* __tstate = wxPyBeginAllowThreads();
30095 result = (bool)wxClipboardLocker___nonzero__(arg1);
30096
30097 wxPyEndAllowThreads(__tstate);
30098 if (PyErr_Occurred()) SWIG_fail;
30099 }
30100 {
30101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30102 }
30103 return resultobj;
30104 fail:
30105 return NULL;
30106 }
30107
30108
30109 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30110 PyObject *obj;
30111 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30112 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30113 Py_INCREF(obj);
30114 return Py_BuildValue((char *)"");
30115 }
30116 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj;
30118 int arg1 = (int) 0 ;
30119 int arg2 = (int) 0 ;
30120 int arg3 = (int) 0 ;
30121 int arg4 = (int) 0 ;
30122 wxVideoMode *result;
30123 PyObject * obj0 = 0 ;
30124 PyObject * obj1 = 0 ;
30125 PyObject * obj2 = 0 ;
30126 PyObject * obj3 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30132 if (obj0) {
30133 {
30134 arg1 = (int)(SWIG_As_int(obj0));
30135 if (SWIG_arg_fail(1)) SWIG_fail;
30136 }
30137 }
30138 if (obj1) {
30139 {
30140 arg2 = (int)(SWIG_As_int(obj1));
30141 if (SWIG_arg_fail(2)) SWIG_fail;
30142 }
30143 }
30144 if (obj2) {
30145 {
30146 arg3 = (int)(SWIG_As_int(obj2));
30147 if (SWIG_arg_fail(3)) SWIG_fail;
30148 }
30149 }
30150 if (obj3) {
30151 {
30152 arg4 = (int)(SWIG_As_int(obj3));
30153 if (SWIG_arg_fail(4)) SWIG_fail;
30154 }
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30173 PyObject * obj0 = 0 ;
30174 char *kwnames[] = {
30175 (char *) "self", NULL
30176 };
30177
30178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30180 if (SWIG_arg_fail(1)) SWIG_fail;
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 delete arg1;
30184
30185 wxPyEndAllowThreads(__tstate);
30186 if (PyErr_Occurred()) SWIG_fail;
30187 }
30188 Py_INCREF(Py_None); resultobj = Py_None;
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj;
30197 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30198 wxVideoMode *arg2 = 0 ;
30199 bool result;
30200 PyObject * obj0 = 0 ;
30201 PyObject * obj1 = 0 ;
30202 char *kwnames[] = {
30203 (char *) "self",(char *) "other", NULL
30204 };
30205
30206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30208 if (SWIG_arg_fail(1)) SWIG_fail;
30209 {
30210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30211 if (SWIG_arg_fail(2)) SWIG_fail;
30212 if (arg2 == NULL) {
30213 SWIG_null_ref("wxVideoMode");
30214 }
30215 if (SWIG_arg_fail(2)) SWIG_fail;
30216 }
30217 {
30218 PyThreadState* __tstate = wxPyBeginAllowThreads();
30219 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30220
30221 wxPyEndAllowThreads(__tstate);
30222 if (PyErr_Occurred()) SWIG_fail;
30223 }
30224 {
30225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30226 }
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj;
30235 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30236 int result;
30237 PyObject * obj0 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "self", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 {
30246 PyThreadState* __tstate = wxPyBeginAllowThreads();
30247 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30248
30249 wxPyEndAllowThreads(__tstate);
30250 if (PyErr_Occurred()) SWIG_fail;
30251 }
30252 {
30253 resultobj = SWIG_From_int((int)(result));
30254 }
30255 return resultobj;
30256 fail:
30257 return NULL;
30258 }
30259
30260
30261 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30262 PyObject *resultobj;
30263 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30264 int result;
30265 PyObject * obj0 = 0 ;
30266 char *kwnames[] = {
30267 (char *) "self", NULL
30268 };
30269
30270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30272 if (SWIG_arg_fail(1)) SWIG_fail;
30273 {
30274 PyThreadState* __tstate = wxPyBeginAllowThreads();
30275 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30276
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 {
30281 resultobj = SWIG_From_int((int)(result));
30282 }
30283 return resultobj;
30284 fail:
30285 return NULL;
30286 }
30287
30288
30289 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30290 PyObject *resultobj;
30291 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30292 int result;
30293 PyObject * obj0 = 0 ;
30294 char *kwnames[] = {
30295 (char *) "self", NULL
30296 };
30297
30298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30300 if (SWIG_arg_fail(1)) SWIG_fail;
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30304
30305 wxPyEndAllowThreads(__tstate);
30306 if (PyErr_Occurred()) SWIG_fail;
30307 }
30308 {
30309 resultobj = SWIG_From_int((int)(result));
30310 }
30311 return resultobj;
30312 fail:
30313 return NULL;
30314 }
30315
30316
30317 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30318 PyObject *resultobj;
30319 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30320 bool result;
30321 PyObject * obj0 = 0 ;
30322 char *kwnames[] = {
30323 (char *) "self", NULL
30324 };
30325
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30332
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 {
30337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30338 }
30339 return resultobj;
30340 fail:
30341 return NULL;
30342 }
30343
30344
30345 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30346 PyObject *resultobj;
30347 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30348 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30349 bool result;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self",(char *) "other", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30360 if (SWIG_arg_fail(2)) SWIG_fail;
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 {
30369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30370 }
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj;
30379 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30380 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30381 bool result;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 char *kwnames[] = {
30385 (char *) "self",(char *) "other", NULL
30386 };
30387
30388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(1)) SWIG_fail;
30391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30392 if (SWIG_arg_fail(2)) SWIG_fail;
30393 {
30394 PyThreadState* __tstate = wxPyBeginAllowThreads();
30395 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30396
30397 wxPyEndAllowThreads(__tstate);
30398 if (PyErr_Occurred()) SWIG_fail;
30399 }
30400 {
30401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30402 }
30403 return resultobj;
30404 fail:
30405 return NULL;
30406 }
30407
30408
30409 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj;
30411 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30412 int arg2 ;
30413 PyObject * obj0 = 0 ;
30414 PyObject * obj1 = 0 ;
30415 char *kwnames[] = {
30416 (char *) "self",(char *) "w", NULL
30417 };
30418
30419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30421 if (SWIG_arg_fail(1)) SWIG_fail;
30422 {
30423 arg2 = (int)(SWIG_As_int(obj1));
30424 if (SWIG_arg_fail(2)) SWIG_fail;
30425 }
30426 if (arg1) (arg1)->w = arg2;
30427
30428 Py_INCREF(Py_None); resultobj = Py_None;
30429 return resultobj;
30430 fail:
30431 return NULL;
30432 }
30433
30434
30435 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30436 PyObject *resultobj;
30437 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30438 int result;
30439 PyObject * obj0 = 0 ;
30440 char *kwnames[] = {
30441 (char *) "self", NULL
30442 };
30443
30444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30446 if (SWIG_arg_fail(1)) SWIG_fail;
30447 result = (int) ((arg1)->w);
30448
30449 {
30450 resultobj = SWIG_From_int((int)(result));
30451 }
30452 return resultobj;
30453 fail:
30454 return NULL;
30455 }
30456
30457
30458 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30459 PyObject *resultobj;
30460 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30461 int arg2 ;
30462 PyObject * obj0 = 0 ;
30463 PyObject * obj1 = 0 ;
30464 char *kwnames[] = {
30465 (char *) "self",(char *) "h", NULL
30466 };
30467
30468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30470 if (SWIG_arg_fail(1)) SWIG_fail;
30471 {
30472 arg2 = (int)(SWIG_As_int(obj1));
30473 if (SWIG_arg_fail(2)) SWIG_fail;
30474 }
30475 if (arg1) (arg1)->h = arg2;
30476
30477 Py_INCREF(Py_None); resultobj = Py_None;
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30485 PyObject *resultobj;
30486 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30487 int result;
30488 PyObject * obj0 = 0 ;
30489 char *kwnames[] = {
30490 (char *) "self", NULL
30491 };
30492
30493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30495 if (SWIG_arg_fail(1)) SWIG_fail;
30496 result = (int) ((arg1)->h);
30497
30498 {
30499 resultobj = SWIG_From_int((int)(result));
30500 }
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30508 PyObject *resultobj;
30509 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30510 int arg2 ;
30511 PyObject * obj0 = 0 ;
30512 PyObject * obj1 = 0 ;
30513 char *kwnames[] = {
30514 (char *) "self",(char *) "bpp", NULL
30515 };
30516
30517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30519 if (SWIG_arg_fail(1)) SWIG_fail;
30520 {
30521 arg2 = (int)(SWIG_As_int(obj1));
30522 if (SWIG_arg_fail(2)) SWIG_fail;
30523 }
30524 if (arg1) (arg1)->bpp = arg2;
30525
30526 Py_INCREF(Py_None); resultobj = Py_None;
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30534 PyObject *resultobj;
30535 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30536 int result;
30537 PyObject * obj0 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 result = (int) ((arg1)->bpp);
30546
30547 {
30548 resultobj = SWIG_From_int((int)(result));
30549 }
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30557 PyObject *resultobj;
30558 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30559 int arg2 ;
30560 PyObject * obj0 = 0 ;
30561 PyObject * obj1 = 0 ;
30562 char *kwnames[] = {
30563 (char *) "self",(char *) "refresh", NULL
30564 };
30565
30566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30568 if (SWIG_arg_fail(1)) SWIG_fail;
30569 {
30570 arg2 = (int)(SWIG_As_int(obj1));
30571 if (SWIG_arg_fail(2)) SWIG_fail;
30572 }
30573 if (arg1) (arg1)->refresh = arg2;
30574
30575 Py_INCREF(Py_None); resultobj = Py_None;
30576 return resultobj;
30577 fail:
30578 return NULL;
30579 }
30580
30581
30582 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30583 PyObject *resultobj;
30584 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30585 int result;
30586 PyObject * obj0 = 0 ;
30587 char *kwnames[] = {
30588 (char *) "self", NULL
30589 };
30590
30591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30593 if (SWIG_arg_fail(1)) SWIG_fail;
30594 result = (int) ((arg1)->refresh);
30595
30596 {
30597 resultobj = SWIG_From_int((int)(result));
30598 }
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30606 PyObject *obj;
30607 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30608 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30609 Py_INCREF(obj);
30610 return Py_BuildValue((char *)"");
30611 }
30612 static int _wrap_DefaultVideoMode_set(PyObject *) {
30613 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30614 return 1;
30615 }
30616
30617
30618 static PyObject *_wrap_DefaultVideoMode_get(void) {
30619 PyObject *pyobj;
30620
30621 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30622 return pyobj;
30623 }
30624
30625
30626 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30627 PyObject *resultobj;
30628 size_t arg1 = (size_t) 0 ;
30629 wxDisplay *result;
30630 PyObject * obj0 = 0 ;
30631 char *kwnames[] = {
30632 (char *) "index", NULL
30633 };
30634
30635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30636 if (obj0) {
30637 {
30638 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30639 if (SWIG_arg_fail(1)) SWIG_fail;
30640 }
30641 }
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 result = (wxDisplay *)new wxDisplay(arg1);
30645
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30657 PyObject *resultobj;
30658 wxDisplay *arg1 = (wxDisplay *) 0 ;
30659 PyObject * obj0 = 0 ;
30660 char *kwnames[] = {
30661 (char *) "self", NULL
30662 };
30663
30664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30666 if (SWIG_arg_fail(1)) SWIG_fail;
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 delete arg1;
30670
30671 wxPyEndAllowThreads(__tstate);
30672 if (PyErr_Occurred()) SWIG_fail;
30673 }
30674 Py_INCREF(Py_None); resultobj = Py_None;
30675 return resultobj;
30676 fail:
30677 return NULL;
30678 }
30679
30680
30681 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30682 PyObject *resultobj;
30683 size_t result;
30684 char *kwnames[] = {
30685 NULL
30686 };
30687
30688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30689 {
30690 PyThreadState* __tstate = wxPyBeginAllowThreads();
30691 result = (size_t)wxDisplay::GetCount();
30692
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 {
30697 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30698 }
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj;
30707 wxPoint *arg1 = 0 ;
30708 int result;
30709 wxPoint temp1 ;
30710 PyObject * obj0 = 0 ;
30711 char *kwnames[] = {
30712 (char *) "pt", NULL
30713 };
30714
30715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30716 {
30717 arg1 = &temp1;
30718 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30719 }
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30723
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = SWIG_From_int((int)(result));
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30737 PyObject *resultobj;
30738 wxWindow *arg1 = (wxWindow *) 0 ;
30739 int result;
30740 PyObject * obj0 = 0 ;
30741 char *kwnames[] = {
30742 (char *) "window", NULL
30743 };
30744
30745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30747 if (SWIG_arg_fail(1)) SWIG_fail;
30748 {
30749 PyThreadState* __tstate = wxPyBeginAllowThreads();
30750 result = (int)wxDisplay::GetFromWindow(arg1);
30751
30752 wxPyEndAllowThreads(__tstate);
30753 if (PyErr_Occurred()) SWIG_fail;
30754 }
30755 {
30756 resultobj = SWIG_From_int((int)(result));
30757 }
30758 return resultobj;
30759 fail:
30760 return NULL;
30761 }
30762
30763
30764 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30765 PyObject *resultobj;
30766 wxDisplay *arg1 = (wxDisplay *) 0 ;
30767 bool result;
30768 PyObject * obj0 = 0 ;
30769 char *kwnames[] = {
30770 (char *) "self", NULL
30771 };
30772
30773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30775 if (SWIG_arg_fail(1)) SWIG_fail;
30776 {
30777 PyThreadState* __tstate = wxPyBeginAllowThreads();
30778 result = (bool)((wxDisplay const *)arg1)->IsOk();
30779
30780 wxPyEndAllowThreads(__tstate);
30781 if (PyErr_Occurred()) SWIG_fail;
30782 }
30783 {
30784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30785 }
30786 return resultobj;
30787 fail:
30788 return NULL;
30789 }
30790
30791
30792 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30793 PyObject *resultobj;
30794 wxDisplay *arg1 = (wxDisplay *) 0 ;
30795 wxRect result;
30796 PyObject * obj0 = 0 ;
30797 char *kwnames[] = {
30798 (char *) "self", NULL
30799 };
30800
30801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30803 if (SWIG_arg_fail(1)) SWIG_fail;
30804 {
30805 PyThreadState* __tstate = wxPyBeginAllowThreads();
30806 result = ((wxDisplay const *)arg1)->GetGeometry();
30807
30808 wxPyEndAllowThreads(__tstate);
30809 if (PyErr_Occurred()) SWIG_fail;
30810 }
30811 {
30812 wxRect * resultptr;
30813 resultptr = new wxRect((wxRect &)(result));
30814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30815 }
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj;
30824 wxDisplay *arg1 = (wxDisplay *) 0 ;
30825 wxString result;
30826 PyObject * obj0 = 0 ;
30827 char *kwnames[] = {
30828 (char *) "self", NULL
30829 };
30830
30831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(1)) SWIG_fail;
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxDisplay const *)arg1)->GetName();
30837
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 #if wxUSE_UNICODE
30843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30844 #else
30845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30846 #endif
30847 }
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30855 PyObject *resultobj;
30856 wxDisplay *arg1 = (wxDisplay *) 0 ;
30857 bool result;
30858 PyObject * obj0 = 0 ;
30859 char *kwnames[] = {
30860 (char *) "self", NULL
30861 };
30862
30863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30865 if (SWIG_arg_fail(1)) SWIG_fail;
30866 {
30867 PyThreadState* __tstate = wxPyBeginAllowThreads();
30868 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30869
30870 wxPyEndAllowThreads(__tstate);
30871 if (PyErr_Occurred()) SWIG_fail;
30872 }
30873 {
30874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30875 }
30876 return resultobj;
30877 fail:
30878 return NULL;
30879 }
30880
30881
30882 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30883 PyObject *resultobj;
30884 wxDisplay *arg1 = (wxDisplay *) 0 ;
30885 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30886 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30887 PyObject *result;
30888 PyObject * obj0 = 0 ;
30889 PyObject * obj1 = 0 ;
30890 char *kwnames[] = {
30891 (char *) "self",(char *) "mode", NULL
30892 };
30893
30894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30896 if (SWIG_arg_fail(1)) SWIG_fail;
30897 if (obj1) {
30898 {
30899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30900 if (SWIG_arg_fail(2)) SWIG_fail;
30901 if (arg2 == NULL) {
30902 SWIG_null_ref("wxVideoMode");
30903 }
30904 if (SWIG_arg_fail(2)) SWIG_fail;
30905 }
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 resultobj = result;
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj;
30923 wxDisplay *arg1 = (wxDisplay *) 0 ;
30924 wxVideoMode result;
30925 PyObject * obj0 = 0 ;
30926 char *kwnames[] = {
30927 (char *) "self", NULL
30928 };
30929
30930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30932 if (SWIG_arg_fail(1)) SWIG_fail;
30933 {
30934 PyThreadState* __tstate = wxPyBeginAllowThreads();
30935 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30936
30937 wxPyEndAllowThreads(__tstate);
30938 if (PyErr_Occurred()) SWIG_fail;
30939 }
30940 {
30941 wxVideoMode * resultptr;
30942 resultptr = new wxVideoMode((wxVideoMode &)(result));
30943 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30944 }
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30952 PyObject *resultobj;
30953 wxDisplay *arg1 = (wxDisplay *) 0 ;
30954 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30955 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30956 bool result;
30957 PyObject * obj0 = 0 ;
30958 PyObject * obj1 = 0 ;
30959 char *kwnames[] = {
30960 (char *) "self",(char *) "mode", NULL
30961 };
30962
30963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30965 if (SWIG_arg_fail(1)) SWIG_fail;
30966 if (obj1) {
30967 {
30968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(2)) SWIG_fail;
30970 if (arg2 == NULL) {
30971 SWIG_null_ref("wxVideoMode");
30972 }
30973 if (SWIG_arg_fail(2)) SWIG_fail;
30974 }
30975 }
30976 {
30977 PyThreadState* __tstate = wxPyBeginAllowThreads();
30978 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30979
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 {
30984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30985 }
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj;
30994 wxDisplay *arg1 = (wxDisplay *) 0 ;
30995 PyObject * obj0 = 0 ;
30996 char *kwnames[] = {
30997 (char *) "self", NULL
30998 };
30999
31000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31002 if (SWIG_arg_fail(1)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->ResetMode();
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31018 PyObject *obj;
31019 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31020 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31021 Py_INCREF(obj);
31022 return Py_BuildValue((char *)"");
31023 }
31024 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31025 PyObject *resultobj;
31026 wxStandardPaths *result;
31027 char *kwnames[] = {
31028 NULL
31029 };
31030
31031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31032 {
31033 PyThreadState* __tstate = wxPyBeginAllowThreads();
31034 result = (wxStandardPaths *)StandardPaths_Get();
31035
31036 wxPyEndAllowThreads(__tstate);
31037 if (PyErr_Occurred()) SWIG_fail;
31038 }
31039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31040 return resultobj;
31041 fail:
31042 return NULL;
31043 }
31044
31045
31046 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31047 PyObject *resultobj;
31048 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31049 wxString result;
31050 PyObject * obj0 = 0 ;
31051 char *kwnames[] = {
31052 (char *) "self", NULL
31053 };
31054
31055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31057 if (SWIG_arg_fail(1)) SWIG_fail;
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31061
31062 wxPyEndAllowThreads(__tstate);
31063 if (PyErr_Occurred()) SWIG_fail;
31064 }
31065 {
31066 #if wxUSE_UNICODE
31067 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31068 #else
31069 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31070 #endif
31071 }
31072 return resultobj;
31073 fail:
31074 return NULL;
31075 }
31076
31077
31078 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31079 PyObject *resultobj;
31080 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31081 wxString result;
31082 PyObject * obj0 = 0 ;
31083 char *kwnames[] = {
31084 (char *) "self", NULL
31085 };
31086
31087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31089 if (SWIG_arg_fail(1)) SWIG_fail;
31090 {
31091 PyThreadState* __tstate = wxPyBeginAllowThreads();
31092 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31093
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 {
31098 #if wxUSE_UNICODE
31099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31100 #else
31101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31102 #endif
31103 }
31104 return resultobj;
31105 fail:
31106 return NULL;
31107 }
31108
31109
31110 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31111 PyObject *resultobj;
31112 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31113 wxString result;
31114 PyObject * obj0 = 0 ;
31115 char *kwnames[] = {
31116 (char *) "self", NULL
31117 };
31118
31119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31121 if (SWIG_arg_fail(1)) SWIG_fail;
31122 {
31123 PyThreadState* __tstate = wxPyBeginAllowThreads();
31124 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31125
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 {
31130 #if wxUSE_UNICODE
31131 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31132 #else
31133 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31134 #endif
31135 }
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj;
31144 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31145 wxString result;
31146 PyObject * obj0 = 0 ;
31147 char *kwnames[] = {
31148 (char *) "self", NULL
31149 };
31150
31151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31153 if (SWIG_arg_fail(1)) SWIG_fail;
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31157
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 {
31162 #if wxUSE_UNICODE
31163 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31164 #else
31165 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31166 #endif
31167 }
31168 return resultobj;
31169 fail:
31170 return NULL;
31171 }
31172
31173
31174 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31175 PyObject *resultobj;
31176 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31177 wxString result;
31178 PyObject * obj0 = 0 ;
31179 char *kwnames[] = {
31180 (char *) "self", NULL
31181 };
31182
31183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31185 if (SWIG_arg_fail(1)) SWIG_fail;
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31189
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 {
31194 #if wxUSE_UNICODE
31195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31196 #else
31197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31198 #endif
31199 }
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31207 PyObject *resultobj;
31208 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31209 wxString result;
31210 PyObject * obj0 = 0 ;
31211 char *kwnames[] = {
31212 (char *) "self", NULL
31213 };
31214
31215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31217 if (SWIG_arg_fail(1)) SWIG_fail;
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31221
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 {
31226 #if wxUSE_UNICODE
31227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31228 #else
31229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31230 #endif
31231 }
31232 return resultobj;
31233 fail:
31234 return NULL;
31235 }
31236
31237
31238 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31239 PyObject *resultobj;
31240 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31241 wxString result;
31242 PyObject * obj0 = 0 ;
31243 char *kwnames[] = {
31244 (char *) "self", NULL
31245 };
31246
31247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31249 if (SWIG_arg_fail(1)) SWIG_fail;
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31253
31254 wxPyEndAllowThreads(__tstate);
31255 if (PyErr_Occurred()) SWIG_fail;
31256 }
31257 {
31258 #if wxUSE_UNICODE
31259 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31260 #else
31261 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31262 #endif
31263 }
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj;
31272 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31273 wxString *arg2 = 0 ;
31274 bool temp2 = false ;
31275 PyObject * obj0 = 0 ;
31276 PyObject * obj1 = 0 ;
31277 char *kwnames[] = {
31278 (char *) "self",(char *) "prefix", NULL
31279 };
31280
31281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31283 if (SWIG_arg_fail(1)) SWIG_fail;
31284 {
31285 arg2 = wxString_in_helper(obj1);
31286 if (arg2 == NULL) SWIG_fail;
31287 temp2 = true;
31288 }
31289 {
31290 PyThreadState* __tstate = wxPyBeginAllowThreads();
31291 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31292
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 Py_INCREF(Py_None); resultobj = Py_None;
31297 {
31298 if (temp2)
31299 delete arg2;
31300 }
31301 return resultobj;
31302 fail:
31303 {
31304 if (temp2)
31305 delete arg2;
31306 }
31307 return NULL;
31308 }
31309
31310
31311 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31312 PyObject *resultobj;
31313 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31314 wxString result;
31315 PyObject * obj0 = 0 ;
31316 char *kwnames[] = {
31317 (char *) "self", NULL
31318 };
31319
31320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31322 if (SWIG_arg_fail(1)) SWIG_fail;
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = wxStandardPaths_GetInstallPrefix(arg1);
31326
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 {
31331 #if wxUSE_UNICODE
31332 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31333 #else
31334 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31335 #endif
31336 }
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31344 PyObject *obj;
31345 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31346 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31347 Py_INCREF(obj);
31348 return Py_BuildValue((char *)"");
31349 }
31350 static PyMethodDef SwigMethods[] = {
31351 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31358 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31365 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31429 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31437 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31455 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31458 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31461 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31464 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31470 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31484 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31490 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31496 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31499 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31513 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31516 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31517 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31520 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31547 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31549 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31551 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31553 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31560 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31566 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31580 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31584 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31587 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31604 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31612 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31659 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31677 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31687 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31703 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31719 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31733 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31742 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31785 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31788 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31791 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31795 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31888 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31889 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31890 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31891 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31908 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31953 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31987 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31995 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31996 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32001 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32010 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32017 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32020 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32023 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32028 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32031 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32032 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32035 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32038 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32042 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32043 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32047 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32051 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32055 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32065 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32076 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32084 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32092 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32106 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32107 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32110 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32128 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32142 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32153 { NULL, NULL, 0, NULL }
32154 };
32155
32156
32157 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32158
32159 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32160 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32161 }
32162 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32163 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32164 }
32165 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32166 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32167 }
32168 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32169 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32170 }
32171 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32172 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32173 }
32174 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32175 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32176 }
32177 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32178 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32179 }
32180 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32181 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32182 }
32183 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32184 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32185 }
32186 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32187 return (void *)((wxEvent *) ((wxPyEvent *) x));
32188 }
32189 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32191 }
32192 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32193 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32194 }
32195 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32196 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32197 }
32198 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32199 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32200 }
32201 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32202 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32203 }
32204 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32205 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32206 }
32207 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32208 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32209 }
32210 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32211 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32212 }
32213 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32214 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32215 }
32216 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32217 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32218 }
32219 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32220 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32221 }
32222 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32223 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32224 }
32225 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32226 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32227 }
32228 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32229 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32230 }
32231 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32232 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32233 }
32234 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32235 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32236 }
32237 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32238 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32239 }
32240 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32241 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32242 }
32243 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32244 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32245 }
32246 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32247 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32248 }
32249 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32250 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32251 }
32252 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32253 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32254 }
32255 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32256 return (void *)((wxEvent *) ((wxShowEvent *) x));
32257 }
32258 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32259 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32260 }
32261 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32263 }
32264 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32266 }
32267 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32268 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32269 }
32270 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32271 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32272 }
32273 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32274 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32275 }
32276 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32277 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32278 }
32279 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32280 return (void *)((wxConfigBase *) ((wxConfig *) x));
32281 }
32282 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32283 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32284 }
32285 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32286 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32287 }
32288 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32289 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32290 }
32291 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32292 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32293 }
32294 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32295 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32296 }
32297 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32298 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32299 }
32300 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32301 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32302 }
32303 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32304 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32305 }
32306 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32307 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32308 }
32309 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32310 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32311 }
32312 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32313 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32314 }
32315 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32316 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32317 }
32318 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32319 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32320 }
32321 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32322 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32323 }
32324 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32325 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32326 }
32327 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32328 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32329 }
32330 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32331 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32332 }
32333 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32334 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32335 }
32336 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32337 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32338 }
32339 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32340 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32341 }
32342 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32343 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32344 }
32345 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32346 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32347 }
32348 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32349 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32350 }
32351 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32352 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32353 }
32354 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32355 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32356 }
32357 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32358 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32359 }
32360 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32361 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32362 }
32363 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32364 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32365 }
32366 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32367 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32368 }
32369 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32370 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32371 }
32372 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32373 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32374 }
32375 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32376 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32377 }
32378 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32379 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32380 }
32381 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32382 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32383 }
32384 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32385 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32386 }
32387 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32388 return (void *)((wxObject *) ((wxSizerItem *) x));
32389 }
32390 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32391 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32392 }
32393 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32394 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32395 }
32396 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32397 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32398 }
32399 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32400 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32401 }
32402 static void *_p_wxSizerTo_p_wxObject(void *x) {
32403 return (void *)((wxObject *) ((wxSizer *) x));
32404 }
32405 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32406 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32407 }
32408 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32409 return (void *)((wxObject *) ((wxFileHistory *) x));
32410 }
32411 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32412 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32413 }
32414 static void *_p_wxEventTo_p_wxObject(void *x) {
32415 return (void *)((wxObject *) ((wxEvent *) x));
32416 }
32417 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32418 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32419 }
32420 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32421 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32422 }
32423 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32424 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32425 }
32426 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32427 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32428 }
32429 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32430 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32431 }
32432 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32433 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32434 }
32435 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32436 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32437 }
32438 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32439 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32440 }
32441 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32442 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32443 }
32444 static void *_p_wxControlTo_p_wxObject(void *x) {
32445 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32446 }
32447 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32448 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32449 }
32450 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32451 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32452 }
32453 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32454 return (void *)((wxObject *) ((wxFSFile *) x));
32455 }
32456 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32457 return (void *)((wxObject *) ((wxClipboard *) x));
32458 }
32459 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32460 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32461 }
32462 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32463 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32464 }
32465 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32466 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32467 }
32468 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32469 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32470 }
32471 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32472 return (void *)((wxObject *) ((wxToolTip *) x));
32473 }
32474 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32475 return (void *)((wxObject *) ((wxMenuItem *) x));
32476 }
32477 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32479 }
32480 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32481 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32482 }
32483 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32485 }
32486 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32487 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32488 }
32489 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32490 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32491 }
32492 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32493 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32494 }
32495 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32496 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32497 }
32498 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32499 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32500 }
32501 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32502 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32503 }
32504 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32505 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32506 }
32507 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32508 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32509 }
32510 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32511 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32512 }
32513 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32514 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32515 }
32516 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32517 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32518 }
32519 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32520 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32521 }
32522 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32523 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32524 }
32525 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32526 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32527 }
32528 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32529 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32530 }
32531 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32532 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32533 }
32534 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32535 return (void *)((wxObject *) ((wxImageHandler *) x));
32536 }
32537 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32538 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32539 }
32540 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32541 return (void *)((wxObject *) ((wxEvtHandler *) x));
32542 }
32543 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32544 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32545 }
32546 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32547 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32548 }
32549 static void *_p_wxImageTo_p_wxObject(void *x) {
32550 return (void *)((wxObject *) ((wxImage *) x));
32551 }
32552 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32553 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32554 }
32555 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32556 return (void *)((wxObject *) ((wxSystemOptions *) x));
32557 }
32558 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32559 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32560 }
32561 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32562 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32563 }
32564 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32565 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32566 }
32567 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32568 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32569 }
32570 static void *_p_wxWindowTo_p_wxObject(void *x) {
32571 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32572 }
32573 static void *_p_wxMenuTo_p_wxObject(void *x) {
32574 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32575 }
32576 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32577 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32578 }
32579 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32580 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32581 }
32582 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32583 return (void *)((wxObject *) ((wxFileSystem *) x));
32584 }
32585 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32586 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32587 }
32588 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32589 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32590 }
32591 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32592 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32593 }
32594 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32595 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32596 }
32597 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32598 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32599 }
32600 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32601 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32602 }
32603 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32604 return (void *)((wxObject *) ((wxBusyInfo *) x));
32605 }
32606 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32607 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32608 }
32609 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32610 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32611 }
32612 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32613 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32614 }
32615 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32616 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32617 }
32618 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32620 }
32621 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32622 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32623 }
32624 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32625 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32626 }
32627 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32628 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32629 }
32630 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32631 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32632 }
32633 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32634 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32635 }
32636 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32637 return (void *)((wxLog *) ((wxLogStderr *) x));
32638 }
32639 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32640 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32641 }
32642 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32643 return (void *)((wxLog *) ((wxLogWindow *) x));
32644 }
32645 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32646 return (void *)((wxLog *) ((wxLogChain *) x));
32647 }
32648 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32649 return (void *)((wxLog *) ((wxLogGui *) x));
32650 }
32651 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32652 return (void *)((wxLog *) ((wxPyLog *) x));
32653 }
32654 static void *_p_wxControlTo_p_wxWindow(void *x) {
32655 return (void *)((wxWindow *) ((wxControl *) x));
32656 }
32657 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32658 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32659 }
32660 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32661 return (void *)((wxWindow *) ((wxMenuBar *) x));
32662 }
32663 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32664 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32665 }
32666 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32667 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32668 }
32669 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}};
32670 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}};
32671 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747 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}};
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766
32767 static swig_type_info *swig_types_initial[] = {
32768 _swigt__p_wxLogChain,
32769 _swigt__p_wxMutexGuiLocker,
32770 _swigt__p_wxMetafile,
32771 _swigt__p_wxFileHistory,
32772 _swigt__p_wxLog,
32773 _swigt__p_wxMenu,
32774 _swigt__p_wxEvent,
32775 _swigt__p_wxDateTime__TimeZone,
32776 _swigt__p_wxConfigBase,
32777 _swigt__p_wxDisplay,
32778 _swigt__p_wxFileType,
32779 _swigt__p_wxLogGui,
32780 _swigt__p_wxFont,
32781 _swigt__p_wxDataFormat,
32782 _swigt__p_wxTimerEvent,
32783 _swigt__p_wxCaret,
32784 _swigt__ptrdiff_t,
32785 _swigt__std__ptrdiff_t,
32786 _swigt__p_int,
32787 _swigt__p_wxSize,
32788 _swigt__p_wxClipboard,
32789 _swigt__p_wxStopWatch,
32790 _swigt__p_wxDC,
32791 _swigt__p_wxClipboardLocker,
32792 _swigt__p_wxIcon,
32793 _swigt__p_wxLogStderr,
32794 _swigt__p_wxLogTextCtrl,
32795 _swigt__p_wxTextCtrl,
32796 _swigt__p_wxBusyCursor,
32797 _swigt__p_wxBitmapDataObject,
32798 _swigt__p_wxTextDataObject,
32799 _swigt__p_wxDataObject,
32800 _swigt__p_wxPyTextDataObject,
32801 _swigt__p_wxPyBitmapDataObject,
32802 _swigt__p_wxFileDataObject,
32803 _swigt__p_wxCustomDataObject,
32804 _swigt__p_wxURLDataObject,
32805 _swigt__p_wxMetafileDataObject,
32806 _swigt__p_wxSound,
32807 _swigt__p_wxTimerRunner,
32808 _swigt__p_wxLogWindow,
32809 _swigt__p_wxTimeSpan,
32810 _swigt__p_wxArrayString,
32811 _swigt__p_wxWindowDisabler,
32812 _swigt__p_form_ops_t,
32813 _swigt__p_wxToolTip,
32814 _swigt__p_wxDataObjectComposite,
32815 _swigt__p_wxSystemSettings,
32816 _swigt__p_wxFileConfig,
32817 _swigt__p_wxVideoMode,
32818 _swigt__p_wxDataObjectSimple,
32819 _swigt__p_wxPyDataObjectSimple,
32820 _swigt__p_wxDuplexMode,
32821 _swigt__p_wxEvtHandler,
32822 _swigt__p_wxRect,
32823 _swigt__p_char,
32824 _swigt__p_wxSingleInstanceChecker,
32825 _swigt__p_wxStandardPaths,
32826 _swigt__p_wxFileTypeInfo,
32827 _swigt__p_wxFrame,
32828 _swigt__p_wxTimer,
32829 _swigt__p_wxPaperSize,
32830 _swigt__p_wxMimeTypesManager,
32831 _swigt__p_wxPyArtProvider,
32832 _swigt__p_wxPyTipProvider,
32833 _swigt__p_wxTipProvider,
32834 _swigt__p_wxJoystick,
32835 _swigt__p_wxSystemOptions,
32836 _swigt__p_wxPoint,
32837 _swigt__p_wxJoystickEvent,
32838 _swigt__p_wxCursor,
32839 _swigt__p_wxObject,
32840 _swigt__p_wxOutputStream,
32841 _swigt__p_wxDateTime,
32842 _swigt__p_wxPyDropSource,
32843 _swigt__p_unsigned_long,
32844 _swigt__p_wxKillError,
32845 _swigt__p_wxWindow,
32846 _swigt__p_wxString,
32847 _swigt__p_wxPyProcess,
32848 _swigt__p_wxBitmap,
32849 _swigt__p_wxConfig,
32850 _swigt__unsigned_int,
32851 _swigt__p_unsigned_int,
32852 _swigt__p_unsigned_char,
32853 _swigt__p_wxChar,
32854 _swigt__p_wxBusyInfo,
32855 _swigt__p_wxPyDropTarget,
32856 _swigt__p_wxPyTextDropTarget,
32857 _swigt__p_wxPyFileDropTarget,
32858 _swigt__p_wxProcessEvent,
32859 _swigt__p_wxPyLog,
32860 _swigt__p_wxLogNull,
32861 _swigt__p_wxColour,
32862 _swigt__p_wxPyTimer,
32863 _swigt__p_wxConfigPathChanger,
32864 _swigt__p_wxDateSpan,
32865 0
32866 };
32867
32868
32869 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32870
32871 static swig_const_info swig_const_table[] = {
32872 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32873 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32874 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32875 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32876 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32877 {0, 0, 0, 0.0, 0, 0}};
32878
32879 #ifdef __cplusplus
32880 }
32881 #endif
32882
32883
32884 #ifdef __cplusplus
32885 extern "C" {
32886 #endif
32887
32888 /* Python-specific SWIG API */
32889 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32890 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32891 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32892
32893 /* -----------------------------------------------------------------------------
32894 * global variable support code.
32895 * ----------------------------------------------------------------------------- */
32896
32897 typedef struct swig_globalvar {
32898 char *name; /* Name of global variable */
32899 PyObject *(*get_attr)(); /* Return the current value */
32900 int (*set_attr)(PyObject *); /* Set the value */
32901 struct swig_globalvar *next;
32902 } swig_globalvar;
32903
32904 typedef struct swig_varlinkobject {
32905 PyObject_HEAD
32906 swig_globalvar *vars;
32907 } swig_varlinkobject;
32908
32909 static PyObject *
32910 swig_varlink_repr(swig_varlinkobject *v) {
32911 v = v;
32912 return PyString_FromString("<Swig global variables>");
32913 }
32914
32915 static int
32916 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32917 swig_globalvar *var;
32918 flags = flags;
32919 fprintf(fp,"Swig global variables { ");
32920 for (var = v->vars; var; var=var->next) {
32921 fprintf(fp,"%s", var->name);
32922 if (var->next) fprintf(fp,", ");
32923 }
32924 fprintf(fp," }\n");
32925 return 0;
32926 }
32927
32928 static PyObject *
32929 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32930 swig_globalvar *var = v->vars;
32931 while (var) {
32932 if (strcmp(var->name,n) == 0) {
32933 return (*var->get_attr)();
32934 }
32935 var = var->next;
32936 }
32937 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32938 return NULL;
32939 }
32940
32941 static int
32942 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32943 swig_globalvar *var = v->vars;
32944 while (var) {
32945 if (strcmp(var->name,n) == 0) {
32946 return (*var->set_attr)(p);
32947 }
32948 var = var->next;
32949 }
32950 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32951 return 1;
32952 }
32953
32954 static PyTypeObject varlinktype = {
32955 PyObject_HEAD_INIT(0)
32956 0, /* Number of items in variable part (ob_size) */
32957 (char *)"swigvarlink", /* Type name (tp_name) */
32958 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32959 0, /* Itemsize (tp_itemsize) */
32960 0, /* Deallocator (tp_dealloc) */
32961 (printfunc) swig_varlink_print, /* Print (tp_print) */
32962 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32963 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32964 0, /* tp_compare */
32965 (reprfunc) swig_varlink_repr, /* tp_repr */
32966 0, /* tp_as_number */
32967 0, /* tp_as_sequence */
32968 0, /* tp_as_mapping */
32969 0, /* tp_hash */
32970 0, /* tp_call */
32971 0, /* tp_str */
32972 0, /* tp_getattro */
32973 0, /* tp_setattro */
32974 0, /* tp_as_buffer */
32975 0, /* tp_flags */
32976 0, /* tp_doc */
32977 #if PY_VERSION_HEX >= 0x02000000
32978 0, /* tp_traverse */
32979 0, /* tp_clear */
32980 #endif
32981 #if PY_VERSION_HEX >= 0x02010000
32982 0, /* tp_richcompare */
32983 0, /* tp_weaklistoffset */
32984 #endif
32985 #if PY_VERSION_HEX >= 0x02020000
32986 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32987 #endif
32988 #if PY_VERSION_HEX >= 0x02030000
32989 0, /* tp_del */
32990 #endif
32991 #ifdef COUNT_ALLOCS
32992 0,0,0,0 /* tp_alloc -> tp_next */
32993 #endif
32994 };
32995
32996 /* Create a variable linking object for use later */
32997 static PyObject *
32998 SWIG_Python_newvarlink(void) {
32999 swig_varlinkobject *result = 0;
33000 result = PyMem_NEW(swig_varlinkobject,1);
33001 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33002 result->ob_type = &varlinktype;
33003 result->vars = 0;
33004 result->ob_refcnt = 0;
33005 Py_XINCREF((PyObject *) result);
33006 return ((PyObject*) result);
33007 }
33008
33009 static void
33010 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33011 swig_varlinkobject *v;
33012 swig_globalvar *gv;
33013 v= (swig_varlinkobject *) p;
33014 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33015 gv->name = (char *) malloc(strlen(name)+1);
33016 strcpy(gv->name,name);
33017 gv->get_attr = get_attr;
33018 gv->set_attr = set_attr;
33019 gv->next = v->vars;
33020 v->vars = gv;
33021 }
33022
33023 /* -----------------------------------------------------------------------------
33024 * constants/methods manipulation
33025 * ----------------------------------------------------------------------------- */
33026
33027 /* Install Constants */
33028 static void
33029 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33030 PyObject *obj = 0;
33031 size_t i;
33032 for (i = 0; constants[i].type; i++) {
33033 switch(constants[i].type) {
33034 case SWIG_PY_INT:
33035 obj = PyInt_FromLong(constants[i].lvalue);
33036 break;
33037 case SWIG_PY_FLOAT:
33038 obj = PyFloat_FromDouble(constants[i].dvalue);
33039 break;
33040 case SWIG_PY_STRING:
33041 if (constants[i].pvalue) {
33042 obj = PyString_FromString((char *) constants[i].pvalue);
33043 } else {
33044 Py_INCREF(Py_None);
33045 obj = Py_None;
33046 }
33047 break;
33048 case SWIG_PY_POINTER:
33049 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33050 break;
33051 case SWIG_PY_BINARY:
33052 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33053 break;
33054 default:
33055 obj = 0;
33056 break;
33057 }
33058 if (obj) {
33059 PyDict_SetItemString(d,constants[i].name,obj);
33060 Py_DECREF(obj);
33061 }
33062 }
33063 }
33064
33065 /* -----------------------------------------------------------------------------*/
33066 /* Fix SwigMethods to carry the callback ptrs when needed */
33067 /* -----------------------------------------------------------------------------*/
33068
33069 static void
33070 SWIG_Python_FixMethods(PyMethodDef *methods,
33071 swig_const_info *const_table,
33072 swig_type_info **types,
33073 swig_type_info **types_initial) {
33074 size_t i;
33075 for (i = 0; methods[i].ml_name; ++i) {
33076 char *c = methods[i].ml_doc;
33077 if (c && (c = strstr(c, "swig_ptr: "))) {
33078 int j;
33079 swig_const_info *ci = 0;
33080 char *name = c + 10;
33081 for (j = 0; const_table[j].type; j++) {
33082 if (strncmp(const_table[j].name, name,
33083 strlen(const_table[j].name)) == 0) {
33084 ci = &(const_table[j]);
33085 break;
33086 }
33087 }
33088 if (ci) {
33089 size_t shift = (ci->ptype) - types;
33090 swig_type_info *ty = types_initial[shift];
33091 size_t ldoc = (c - methods[i].ml_doc);
33092 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33093 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33094 char *buff = ndoc;
33095 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33096 strncpy(buff, methods[i].ml_doc, ldoc);
33097 buff += ldoc;
33098 strncpy(buff, "swig_ptr: ", 10);
33099 buff += 10;
33100 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33101 methods[i].ml_doc = ndoc;
33102 }
33103 }
33104 }
33105 }
33106
33107 /* -----------------------------------------------------------------------------*
33108 * Initialize type list
33109 * -----------------------------------------------------------------------------*/
33110
33111 #if PY_MAJOR_VERSION < 2
33112 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33113 is copied out of Python/modsupport.c in python version 2.3.4 */
33114 static int
33115 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33116 {
33117 PyObject *dict;
33118 if (!PyModule_Check(m)) {
33119 PyErr_SetString(PyExc_TypeError,
33120 "PyModule_AddObject() needs module as first arg");
33121 return -1;
33122 }
33123 if (!o) {
33124 PyErr_SetString(PyExc_TypeError,
33125 "PyModule_AddObject() needs non-NULL value");
33126 return -1;
33127 }
33128
33129 dict = PyModule_GetDict(m);
33130 if (dict == NULL) {
33131 /* Internal error -- modules must have a dict! */
33132 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33133 PyModule_GetName(m));
33134 return -1;
33135 }
33136 if (PyDict_SetItemString(dict, name, o))
33137 return -1;
33138 Py_DECREF(o);
33139 return 0;
33140 }
33141 #endif
33142
33143 static swig_type_info **
33144 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33145 static PyMethodDef swig_empty_runtime_method_table[] = {
33146 {
33147 NULL, NULL, 0, NULL
33148 }
33149 };/* Sentinel */
33150
33151 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33152 swig_empty_runtime_method_table);
33153 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33154 if (pointer && module) {
33155 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33156 }
33157 return type_list_handle;
33158 }
33159
33160 static swig_type_info **
33161 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33162 swig_type_info **type_pointer;
33163
33164 /* first check if module already created */
33165 type_pointer = SWIG_Python_GetTypeListHandle();
33166 if (type_pointer) {
33167 return type_pointer;
33168 } else {
33169 /* create a new module and variable */
33170 return SWIG_Python_SetTypeListHandle(type_list_handle);
33171 }
33172 }
33173
33174 #ifdef __cplusplus
33175 }
33176 #endif
33177
33178 /* -----------------------------------------------------------------------------*
33179 * Partial Init method
33180 * -----------------------------------------------------------------------------*/
33181
33182 #ifdef SWIG_LINK_RUNTIME
33183 #ifdef __cplusplus
33184 extern "C"
33185 #endif
33186 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33187 #endif
33188
33189 #ifdef __cplusplus
33190 extern "C"
33191 #endif
33192 SWIGEXPORT(void) SWIG_init(void) {
33193 static PyObject *SWIG_globals = 0;
33194 static int typeinit = 0;
33195 PyObject *m, *d;
33196 int i;
33197 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33198
33199 /* Fix SwigMethods to carry the callback ptrs when needed */
33200 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33201
33202 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33203 d = PyModule_GetDict(m);
33204
33205 if (!typeinit) {
33206 #ifdef SWIG_LINK_RUNTIME
33207 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33208 #else
33209 # ifndef SWIG_STATIC_RUNTIME
33210 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33211 # endif
33212 #endif
33213 for (i = 0; swig_types_initial[i]; i++) {
33214 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33215 }
33216 typeinit = 1;
33217 }
33218 SWIG_InstallConstants(d,swig_const_table);
33219
33220 {
33221 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33222 }
33223 {
33224 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33225 }
33226 {
33227 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33228 }
33229 {
33230 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33231 }
33232 {
33233 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33234 }
33235 {
33236 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33237 }
33238 {
33239 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33240 }
33241 {
33242 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33243 }
33244 {
33245 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33246 }
33247 {
33248 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33249 }
33250 {
33251 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33252 }
33253 {
33254 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33255 }
33256 {
33257 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33258 }
33259 {
33260 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33261 }
33262 {
33263 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33264 }
33265 {
33266 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33267 }
33268 {
33269 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33270 }
33271 {
33272 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33273 }
33274 {
33275 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33276 }
33277 {
33278 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33279 }
33280 {
33281 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33282 }
33283 {
33284 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33285 }
33286 {
33287 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33288 }
33289 {
33290 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33291 }
33292 {
33293 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33294 }
33295 {
33296 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33297 }
33298 {
33299 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33300 }
33301 {
33302 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33303 }
33304 {
33305 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33306 }
33307 {
33308 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33309 }
33310 {
33311 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33312 }
33313 {
33314 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33315 }
33316 {
33317 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33318 }
33319 {
33320 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33321 }
33322 {
33323 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33324 }
33325 {
33326 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33327 }
33328 {
33329 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33330 }
33331 {
33332 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33333 }
33334 {
33335 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33336 }
33337 {
33338 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33339 }
33340 {
33341 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33342 }
33343 {
33344 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33345 }
33346 {
33347 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33348 }
33349 {
33350 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33351 }
33352 {
33353 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33354 }
33355 {
33356 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33357 }
33358 {
33359 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33360 }
33361 {
33362 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33363 }
33364 {
33365 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33366 }
33367 {
33368 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33369 }
33370 {
33371 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33372 }
33373 {
33374 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33375 }
33376 {
33377 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33378 }
33379 {
33380 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33381 }
33382 {
33383 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33384 }
33385 {
33386 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33387 }
33388 {
33389 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33390 }
33391 {
33392 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33393 }
33394 {
33395 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33396 }
33397 {
33398 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33399 }
33400 {
33401 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33402 }
33403 {
33404 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33405 }
33406 {
33407 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33408 }
33409 {
33410 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33411 }
33412 {
33413 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33414 }
33415 {
33416 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33417 }
33418 {
33419 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33429 }
33430 {
33431 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33432 }
33433 {
33434 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33435 }
33436 {
33437 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33438 }
33439 {
33440 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33441 }
33442 {
33443 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33444 }
33445 {
33446 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33447 }
33448 {
33449 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33450 }
33451 {
33452 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33453 }
33454 {
33455 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33456 }
33457 {
33458 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33459 }
33460 {
33461 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33462 }
33463 {
33464 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33465 }
33466 {
33467 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33468 }
33469 {
33470 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33471 }
33472 {
33473 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33492 }
33493 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33494 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33495 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33496 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33497 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33498 {
33499 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33500 }
33501 {
33502 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33503 }
33504 {
33505 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33506 }
33507 {
33508 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33509 }
33510 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33511
33512 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33513
33514 {
33515 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33546 }
33547 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33548 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33549 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33550 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33551 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33552 {
33553 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33554 }
33555 {
33556 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33557 }
33558 {
33559 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33560 }
33561 {
33562 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33563 }
33564 {
33565 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33566 }
33567 {
33568 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33569 }
33570 {
33571 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33572 }
33573 {
33574 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33575 }
33576 {
33577 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33578 }
33579 {
33580 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33581 }
33582 {
33583 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33584 }
33585 {
33586 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33587 }
33588 {
33589 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33590 }
33591 {
33592 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33593 }
33594 {
33595 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33596 }
33597 {
33598 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33599 }
33600 {
33601 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33602 }
33603 {
33604 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33605 }
33606 {
33607 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33608 }
33609 {
33610 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33632 }
33633 {
33634 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33635 }
33636 {
33637 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33638 }
33639 {
33640 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33641 }
33642 {
33643 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33644 }
33645 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33646 {
33647 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33660 }
33661
33662 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33663
33664 {
33665 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33675 }
33676 {
33677 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33678 }
33679 {
33680 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33681 }
33682 {
33683 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33684 }
33685 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33686 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33687 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33688 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33689 {
33690 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33691 }
33692 {
33693 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33712 }
33713 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33714 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33715 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33716 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33717 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33718 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33719 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33723 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33724 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33725 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33726 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33727 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33732 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33733 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33734 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33735 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33736 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33737 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33738 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33739 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33740 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33741 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33742 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33743 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33744 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33745 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33749 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33750 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33751 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33752 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33753 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33754 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33755 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33756 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33757 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33758 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33759 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33760 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33761 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33762 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33763 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33764 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33765 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33766 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33769
33770 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33771
33772 {
33773 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33798 }
33799 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33800 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33801 {
33802 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33803 }
33804 {
33805 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33806 }
33807 {
33808 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33809 }
33810 {
33811 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33812 }
33813 {
33814 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33815 }
33816 {
33817 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33818 }
33819 {
33820 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33821 }
33822 {
33823 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33824 }
33825 {
33826 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33827 }
33828 {
33829 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33830 }
33831 {
33832 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33833 }
33834 {
33835 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33836 }
33837 {
33838 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33839 }
33840 {
33841 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33842 }
33843 {
33844 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33845 }
33846 {
33847 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33848 }
33849 {
33850 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33851 }
33852 {
33853 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33854 }
33855 {
33856 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33857 }
33858 {
33859 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33860 }
33861 {
33862 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33863 }
33864 {
33865 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33866 }
33867 {
33868 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33869 }
33870 {
33871 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33872 }
33873 {
33874 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33875 }
33876 {
33877 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33878 }
33879 {
33880 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33881 }
33882 {
33883 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33884 }
33885 {
33886 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33887 }
33888 {
33889 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33890 }
33891 {
33892 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33893 }
33894 {
33895 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33896 }
33897 {
33898 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33899 }
33900 {
33901 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33902 }
33903 {
33904 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33905 }
33906 {
33907 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33908 }
33909 {
33910 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33911 }
33912 {
33913 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33914 }
33915 {
33916 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33917 }
33918 {
33919 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33920 }
33921 {
33922 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33923 }
33924 {
33925 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33926 }
33927 {
33928 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33929 }
33930 {
33931 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33932 }
33933 {
33934 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33935 }
33936 {
33937 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33938 }
33939 {
33940 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33941 }
33942 {
33943 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33944 }
33945 {
33946 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33947 }
33948 {
33949 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33950 }
33951 {
33952 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33953 }
33954 {
33955 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33956 }
33957 {
33958 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33959 }
33960 {
33961 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33962 }
33963 {
33964 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33965 }
33966 {
33967 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33968 }
33969 {
33970 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33971 }
33972 {
33973 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33974 }
33975 {
33976 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33977 }
33978 {
33979 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33980 }
33981 {
33982 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33983 }
33984 {
33985 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33986 }
33987 {
33988 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33989 }
33990 {
33991 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33992 }
33993 {
33994 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33995 }
33996 {
33997 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33998 }
33999 {
34000 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34001 }
34002 {
34003 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34004 }
34005 {
34006 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34007 }
34008 {
34009 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34010 }
34011 {
34012 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34013 }
34014 {
34015 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34016 }
34017 {
34018 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34019 }
34020 {
34021 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34022 }
34023 {
34024 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34025 }
34026 {
34027 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34028 }
34029 {
34030 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34031 }
34032 {
34033 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34034 }
34035 {
34036 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34037 }
34038 {
34039 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34040 }
34041 {
34042 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34043 }
34044 {
34045 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34046 }
34047 {
34048 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34049 }
34050 {
34051 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34052 }
34053 {
34054 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34055 }
34056 {
34057 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34058 }
34059 {
34060 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34061 }
34062 {
34063 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34064 }
34065 {
34066 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34067 }
34068 {
34069 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34070 }
34071 {
34072 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34073 }
34074 {
34075 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34076 }
34077 {
34078 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34079 }
34080 {
34081 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34082 }
34083 {
34084 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34085 }
34086 {
34087 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34088 }
34089 {
34090 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34091 }
34092 {
34093 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34094 }
34095 {
34096 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34097 }
34098 {
34099 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34100 }
34101 {
34102 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34103 }
34104 {
34105 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34106 }
34107 {
34108 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34109 }
34110 {
34111 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34112 }
34113 {
34114 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34115 }
34116 {
34117 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34118 }
34119 {
34120 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34121 }
34122 {
34123 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34124 }
34125 {
34126 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34127 }
34128 {
34129 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34130 }
34131 {
34132 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34133 }
34134 {
34135 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34136 }
34137 {
34138 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34139 }
34140 {
34141 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34142 }
34143 {
34144 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34145 }
34146 {
34147 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34148 }
34149 {
34150 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34151 }
34152 {
34153 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34154 }
34155 {
34156 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34157 }
34158 {
34159 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34160 }
34161 {
34162 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34163 }
34164 {
34165 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34166 }
34167 {
34168 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34169 }
34170 {
34171 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34172 }
34173 {
34174 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34175 }
34176 {
34177 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34178 }
34179 {
34180 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34181 }
34182 {
34183 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34184 }
34185 {
34186 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34187 }
34188 {
34189 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34190 }
34191 {
34192 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34193 }
34194 {
34195 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34196 }
34197 {
34198 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34199 }
34200 {
34201 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34202 }
34203 {
34204 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34205 }
34206 {
34207 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34208 }
34209 {
34210 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34211 }
34212 {
34213 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34214 }
34215 {
34216 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34217 }
34218 {
34219 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34220 }
34221 {
34222 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34223 }
34224 {
34225 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34226 }
34227 {
34228 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34229 }
34230 {
34231 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34232 }
34233 {
34234 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34235 }
34236 {
34237 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34238 }
34239 {
34240 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34241 }
34242 {
34243 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34244 }
34245 {
34246 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34247 }
34248 {
34249 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34265 }
34266 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34267 {
34268 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34296 }
34297 {
34298 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34299 }
34300 {
34301 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34302 }
34303 {
34304 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34305 }
34306 {
34307 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34308 }
34309 {
34310 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34311 }
34312 {
34313 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34314 }
34315 {
34316 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34317 }
34318 {
34319 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34320 }
34321 {
34322 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34323 }
34324 {
34325 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34326 }
34327 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34328 {
34329 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34357 }
34358 {
34359 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34360 }
34361 {
34362 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34363 }
34364
34365 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34366 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34367 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34368 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34369
34370 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34371 }
34372
wxWidgets (Impactor)