]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_misc_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / gtk / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 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_wxFileHistory swig_types[2]
1344 #define SWIGTYPE_p_wxLog swig_types[3]
1345 #define SWIGTYPE_p_wxMenu swig_types[4]
1346 #define SWIGTYPE_p_wxEvent swig_types[5]
1347 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[6]
1348 #define SWIGTYPE_p_wxConfigBase swig_types[7]
1349 #define SWIGTYPE_p_wxDisplay swig_types[8]
1350 #define SWIGTYPE_p_wxFileType swig_types[9]
1351 #define SWIGTYPE_p_wxLogGui swig_types[10]
1352 #define SWIGTYPE_p_wxFont swig_types[11]
1353 #define SWIGTYPE_p_wxDataFormat swig_types[12]
1354 #define SWIGTYPE_p_wxTimerEvent swig_types[13]
1355 #define SWIGTYPE_p_wxCaret swig_types[14]
1356 #define SWIGTYPE_ptrdiff_t swig_types[15]
1357 #define SWIGTYPE_std__ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_p_int swig_types[17]
1359 #define SWIGTYPE_p_wxSize swig_types[18]
1360 #define SWIGTYPE_p_wxClipboard swig_types[19]
1361 #define SWIGTYPE_p_wxStopWatch swig_types[20]
1362 #define SWIGTYPE_p_wxDC swig_types[21]
1363 #define SWIGTYPE_p_wxClipboardLocker swig_types[22]
1364 #define SWIGTYPE_p_wxIcon swig_types[23]
1365 #define SWIGTYPE_p_wxLogStderr swig_types[24]
1366 #define SWIGTYPE_p_wxLogTextCtrl swig_types[25]
1367 #define SWIGTYPE_p_wxTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxBusyCursor swig_types[27]
1369 #define SWIGTYPE_p_wxBitmapDataObject swig_types[28]
1370 #define SWIGTYPE_p_wxTextDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxPyTextDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxFileDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxCustomDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxURLDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxMetafileDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxSound swig_types[37]
1379 #define SWIGTYPE_p_wxTimerRunner swig_types[38]
1380 #define SWIGTYPE_p_wxLogWindow swig_types[39]
1381 #define SWIGTYPE_p_wxTimeSpan swig_types[40]
1382 #define SWIGTYPE_p_wxArrayString swig_types[41]
1383 #define SWIGTYPE_p_wxWindowDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxToolTip swig_types[44]
1386 #define SWIGTYPE_p_wxDataObjectComposite swig_types[45]
1387 #define SWIGTYPE_p_wxSystemSettings swig_types[46]
1388 #define SWIGTYPE_p_wxFileConfig swig_types[47]
1389 #define SWIGTYPE_p_wxVideoMode swig_types[48]
1390 #define SWIGTYPE_p_wxDataObjectSimple swig_types[49]
1391 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxDuplexMode swig_types[51]
1393 #define SWIGTYPE_p_wxEvtHandler swig_types[52]
1394 #define SWIGTYPE_p_wxRect swig_types[53]
1395 #define SWIGTYPE_p_char swig_types[54]
1396 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[55]
1397 #define SWIGTYPE_p_wxStandardPaths swig_types[56]
1398 #define SWIGTYPE_p_wxFileTypeInfo swig_types[57]
1399 #define SWIGTYPE_p_wxFrame swig_types[58]
1400 #define SWIGTYPE_p_wxTimer swig_types[59]
1401 #define SWIGTYPE_p_wxPaperSize swig_types[60]
1402 #define SWIGTYPE_p_wxMimeTypesManager swig_types[61]
1403 #define SWIGTYPE_p_wxPyArtProvider swig_types[62]
1404 #define SWIGTYPE_p_wxPyTipProvider swig_types[63]
1405 #define SWIGTYPE_p_wxTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxJoystick swig_types[65]
1407 #define SWIGTYPE_p_wxSystemOptions swig_types[66]
1408 #define SWIGTYPE_p_wxPoint swig_types[67]
1409 #define SWIGTYPE_p_wxJoystickEvent swig_types[68]
1410 #define SWIGTYPE_p_wxCursor swig_types[69]
1411 #define SWIGTYPE_p_wxObject swig_types[70]
1412 #define SWIGTYPE_p_wxOutputStream swig_types[71]
1413 #define SWIGTYPE_p_wxDateTime swig_types[72]
1414 #define SWIGTYPE_p_wxPyDropSource swig_types[73]
1415 #define SWIGTYPE_p_unsigned_long swig_types[74]
1416 #define SWIGTYPE_p_wxKillError swig_types[75]
1417 #define SWIGTYPE_p_wxWindow swig_types[76]
1418 #define SWIGTYPE_p_wxString swig_types[77]
1419 #define SWIGTYPE_p_wxPyProcess swig_types[78]
1420 #define SWIGTYPE_p_wxBitmap swig_types[79]
1421 #define SWIGTYPE_p_wxConfig swig_types[80]
1422 #define SWIGTYPE_unsigned_int swig_types[81]
1423 #define SWIGTYPE_p_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_char swig_types[83]
1425 #define SWIGTYPE_p_wxChar swig_types[84]
1426 #define SWIGTYPE_p_wxBusyInfo swig_types[85]
1427 #define SWIGTYPE_p_wxPyDropTarget swig_types[86]
1428 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxProcessEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPyLog swig_types[90]
1432 #define SWIGTYPE_p_wxLogNull swig_types[91]
1433 #define SWIGTYPE_p_wxColour swig_types[92]
1434 #define SWIGTYPE_p_wxPyTimer swig_types[93]
1435 #define SWIGTYPE_p_wxConfigPathChanger swig_types[94]
1436 #define SWIGTYPE_p_wxDateSpan swig_types[95]
1437 static swig_type_info *swig_types[97];
1438
1439 /* -------- TYPES TABLE (END) -------- */
1440
1441
1442 /*-----------------------------------------------
1443 @(target):= _misc_.so
1444 ------------------------------------------------*/
1445 #define SWIG_init init_misc_
1446
1447 #define SWIG_name "_misc_"
1448
1449 #include "wx/wxPython/wxPython.h"
1450 #include "wx/wxPython/pyclasses.h"
1451 #include "wx/wxPython/pyistream.h"
1452
1453 static const wxString wxPyEmptyString(wxEmptyString);
1454
1455
1456
1457 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1458 #define SWIG_From_int PyInt_FromLong
1459 /*@@*/
1460
1461
1462 #include <limits.h>
1463
1464
1465 SWIGINTERN int
1466 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1467 const char *errmsg)
1468 {
1469 if (value < min_value) {
1470 if (errmsg) {
1471 PyErr_Format(PyExc_OverflowError,
1472 "value %ld is less than '%s' minimum %ld",
1473 value, errmsg, min_value);
1474 }
1475 return 0;
1476 } else if (value > max_value) {
1477 if (errmsg) {
1478 PyErr_Format(PyExc_OverflowError,
1479 "value %ld is greater than '%s' maximum %ld",
1480 value, errmsg, max_value);
1481 }
1482 return 0;
1483 }
1484 return 1;
1485 }
1486
1487
1488 SWIGINTERN int
1489 SWIG_AsVal_long(PyObject* obj, long* val)
1490 {
1491 if (PyNumber_Check(obj)) {
1492 if (val) *val = PyInt_AsLong(obj);
1493 return 1;
1494 }
1495 else {
1496 SWIG_type_error("number", obj);
1497 }
1498 return 0;
1499 }
1500
1501
1502 #if INT_MAX != LONG_MAX
1503 SWIGINTERN int
1504 SWIG_AsVal_int(PyObject *obj, int *val)
1505 {
1506 const char* errmsg = val ? "int" : (char*)0;
1507 long v;
1508 if (SWIG_AsVal_long(obj, &v)) {
1509 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1510 if (val) *val = (int)(v);
1511 return 1;
1512 } else {
1513 return 0;
1514 }
1515 } else {
1516 PyErr_Clear();
1517 }
1518 if (val) {
1519 SWIG_type_error(errmsg, obj);
1520 }
1521 return 0;
1522 }
1523 #else
1524 SWIGINTERNSHORT int
1525 SWIG_AsVal_int(PyObject *obj, int *val)
1526 {
1527 return SWIG_AsVal_long(obj,(long*)val);
1528 }
1529 #endif
1530
1531
1532 SWIGINTERNSHORT int
1533 SWIG_As_int(PyObject* obj)
1534 {
1535 int v;
1536 if (!SWIG_AsVal_int(obj, &v)) {
1537 /*
1538 this is needed to make valgrind/purify happier.
1539 */
1540 memset((void*)&v, 0, sizeof(int));
1541 }
1542 return v;
1543 }
1544
1545
1546 SWIGINTERNSHORT int
1547 SWIG_Check_int(PyObject* obj)
1548 {
1549 return SWIG_AsVal_int(obj, (int*)0);
1550 }
1551
1552 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1553
1554 #include <wx/stockitem.h>
1555
1556 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1557 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1558 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1559
1560 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1561 #define SWIG_From_long PyInt_FromLong
1562 /*@@*/
1563
1564
1565 SWIGINTERNSHORT long
1566 SWIG_As_long(PyObject* obj)
1567 {
1568 long v;
1569 if (!SWIG_AsVal_long(obj, &v)) {
1570 /*
1571 this is needed to make valgrind/purify happier.
1572 */
1573 memset((void*)&v, 0, sizeof(long));
1574 }
1575 return v;
1576 }
1577
1578
1579 SWIGINTERNSHORT int
1580 SWIG_Check_long(PyObject* obj)
1581 {
1582 return SWIG_AsVal_long(obj, (long*)0);
1583 }
1584
1585
1586 SWIGINTERN int
1587 SWIG_AsVal_bool(PyObject *obj, bool *val)
1588 {
1589 if (obj == Py_True) {
1590 if (val) *val = true;
1591 return 1;
1592 }
1593 if (obj == Py_False) {
1594 if (val) *val = false;
1595 return 1;
1596 }
1597 int res = 0;
1598 if (SWIG_AsVal_int(obj, &res)) {
1599 if (val) *val = res ? true : false;
1600 return 1;
1601 } else {
1602 PyErr_Clear();
1603 }
1604 if (val) {
1605 SWIG_type_error("bool", obj);
1606 }
1607 return 0;
1608 }
1609
1610
1611 SWIGINTERNSHORT bool
1612 SWIG_As_bool(PyObject* obj)
1613 {
1614 bool v;
1615 if (!SWIG_AsVal_bool(obj, &v)) {
1616 /*
1617 this is needed to make valgrind/purify happier.
1618 */
1619 memset((void*)&v, 0, sizeof(bool));
1620 }
1621 return v;
1622 }
1623
1624
1625 SWIGINTERNSHORT int
1626 SWIG_Check_bool(PyObject* obj)
1627 {
1628 return SWIG_AsVal_bool(obj, (bool*)0);
1629 }
1630
1631
1632 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1633 PyObject* o2;
1634 PyObject* o3;
1635
1636 if (!target) {
1637 target = o;
1638 } else if (target == Py_None) {
1639 Py_DECREF(Py_None);
1640 target = o;
1641 } else {
1642 if (!PyTuple_Check(target)) {
1643 o2 = target;
1644 target = PyTuple_New(1);
1645 PyTuple_SetItem(target, 0, o2);
1646 }
1647 o3 = PyTuple_New(1);
1648 PyTuple_SetItem(o3, 0, o);
1649
1650 o2 = target;
1651 target = PySequence_Concat(o2, o3);
1652 Py_DECREF(o2);
1653 Py_DECREF(o3);
1654 }
1655 return target;
1656 }
1657
1658
1659
1660 long wxGetFreeMemory()
1661 { wxPyRaiseNotImplemented(); return 0; }
1662
1663
1664 SWIGINTERN int
1665 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1666 {
1667 long v = 0;
1668 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1669 SWIG_type_error("unsigned number", obj);
1670 }
1671 else if (val)
1672 *val = (unsigned long)v;
1673 return 1;
1674 }
1675
1676
1677 SWIGINTERNSHORT unsigned long
1678 SWIG_As_unsigned_SS_long(PyObject* obj)
1679 {
1680 unsigned long v;
1681 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1682 /*
1683 this is needed to make valgrind/purify happier.
1684 */
1685 memset((void*)&v, 0, sizeof(unsigned long));
1686 }
1687 return v;
1688 }
1689
1690
1691 SWIGINTERNSHORT int
1692 SWIG_Check_unsigned_SS_long(PyObject* obj)
1693 {
1694 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1695 }
1696
1697
1698 SWIGINTERNSHORT PyObject*
1699 SWIG_From_unsigned_SS_long(unsigned long value)
1700 {
1701 return (value > LONG_MAX) ?
1702 PyLong_FromUnsignedLong(value)
1703 : PyInt_FromLong((long)(value));
1704 }
1705
1706
1707 void wxWakeUpMainThread() {}
1708
1709
1710 bool wxThread_IsMain() {
1711 #ifdef WXP_WITH_THREAD
1712 return wxThread::IsMain();
1713 #else
1714 return true;
1715 #endif
1716 }
1717
1718 static void wxCaret_Destroy(wxCaret *self){
1719 delete self;
1720 }
1721
1722 #include <wx/snglinst.h>
1723
1724
1725 #ifdef __WXMSW__
1726 #include <wx/msw/private.h>
1727 #include <wx/dynload.h>
1728 #endif
1729
1730
1731
1732 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1733 #if 0
1734 , int method
1735 #endif
1736 )
1737 {
1738 #ifdef __WXMSW__
1739 #if 0
1740 switch (method)
1741 {
1742 case 1:
1743 // This one only partially works. Appears to be an undocumented
1744 // "standard" convention that not all widgets adhear to. For
1745 // example, for some widgets backgrounds or non-client areas may
1746 // not be painted.
1747 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1748 break;
1749
1750 case 2:
1751 #endif
1752 // This one works much better, nearly all widgets and their
1753 // children are captured correctly[**]. Prior to the big
1754 // background erase changes that Vadim did in 2004-2005 this
1755 // method failed badly on XP with Themes activated, most native
1756 // widgets draw only partially, if at all. Without themes it
1757 // worked just like on Win2k. After those changes this method
1758 // works very well.
1759 //
1760 // ** For example the radio buttons in a wxRadioBox are not its
1761 // children by default, but you can capture it via the panel
1762 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1763 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1764 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1765 PRF_ERASEBKGND | PRF_OWNED );
1766 return true;
1767 #if 0
1768 break;
1769
1770 case 3:
1771 // This one is only defined in the latest SDK and is only
1772 // available on XP. MSDN says it is similar to sending WM_PRINT
1773 // so I expect that it will work similar to the above. Since it
1774 // is avaialble only on XP, it can't be compiled like this and
1775 // will have to be loaded dynamically.
1776 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1777
1778 // fall through
1779
1780 case 4:
1781 // Use PrintWindow if available, or fallback to WM_PRINT
1782 // otherwise. Unfortunately using PrintWindow is even worse than
1783 // WM_PRINT. For most native widgets nothing is drawn to the dc
1784 // at all, with or without Themes.
1785 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1786 static bool s_triedToLoad = false;
1787 static PrintWindow_t pfnPrintWindow = NULL;
1788 if ( !s_triedToLoad )
1789 {
1790
1791 s_triedToLoad = true;
1792 wxDynamicLibrary dllUser32(_T("user32.dll"));
1793 if ( dllUser32.IsLoaded() )
1794 {
1795 wxLogNull nolog; // Don't report errors here
1796 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1797 }
1798 }
1799 if (pfnPrintWindow)
1800 {
1801 //printf("Using PrintWindow\n");
1802 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1803 }
1804 else
1805 {
1806 //printf("Using WM_PRINT\n");
1807 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1808 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1809 PRF_ERASEBKGND | PRF_OWNED );
1810 }
1811 }
1812 #endif // 0
1813 #else
1814 return false;
1815 #endif // __WXMSW__
1816 }
1817
1818
1819
1820 #include <wx/tipdlg.h>
1821
1822
1823 class wxPyTipProvider : public wxTipProvider {
1824 public:
1825 wxPyTipProvider(size_t currentTip)
1826 : wxTipProvider(currentTip) {}
1827
1828 DEC_PYCALLBACK_STRING__pure(GetTip);
1829 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1830 PYPRIVATE;
1831 };
1832
1833 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1834 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1835
1836
1837 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1838
1839 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1840
1841 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1842 : wxTimer(owner, id)
1843 {
1844 if (owner == NULL) SetOwner(this);
1845 }
1846
1847
1848 void wxPyTimer::Notify() {
1849 bool found;
1850 bool blocked = wxPyBeginBlockThreads();
1851 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1852 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1853 wxPyEndBlockThreads(blocked);
1854 if (! found)
1855 wxTimer::Notify();
1856 }
1857 void wxPyTimer::base_Notify() {
1858 wxTimer::Notify();
1859 }
1860
1861
1862
1863 SWIGINTERN PyObject *
1864 SWIG_FromCharPtr(const char* cptr)
1865 {
1866 if (cptr) {
1867 size_t size = strlen(cptr);
1868 if (size > INT_MAX) {
1869 return SWIG_NewPointerObj((char*)(cptr),
1870 SWIG_TypeQuery("char *"), 0);
1871 } else {
1872 if (size != 0) {
1873 return PyString_FromStringAndSize(cptr, size);
1874 } else {
1875 return PyString_FromString(cptr);
1876 }
1877 }
1878 }
1879 Py_INCREF(Py_None);
1880 return Py_None;
1881 }
1882
1883
1884 SWIGINTERNSHORT int
1885 SWIG_CheckUnsignedLongInRange(unsigned long value,
1886 unsigned long max_value,
1887 const char *errmsg)
1888 {
1889 if (value > max_value) {
1890 if (errmsg) {
1891 PyErr_Format(PyExc_OverflowError,
1892 "value %lu is greater than '%s' minimum %lu",
1893 value, errmsg, max_value);
1894 }
1895 return 0;
1896 }
1897 return 1;
1898 }
1899
1900
1901 #if UINT_MAX != ULONG_MAX
1902 SWIGINTERN int
1903 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1904 {
1905 const char* errmsg = val ? "unsigned int" : (char*)0;
1906 unsigned long v;
1907 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1908 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1909 if (val) *val = (unsigned int)(v);
1910 return 1;
1911 }
1912 } else {
1913 PyErr_Clear();
1914 }
1915 if (val) {
1916 SWIG_type_error(errmsg, obj);
1917 }
1918 return 0;
1919 }
1920 #else
1921 SWIGINTERNSHORT unsigned int
1922 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1923 {
1924 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1925 }
1926 #endif
1927
1928
1929 SWIGINTERNSHORT unsigned int
1930 SWIG_As_unsigned_SS_int(PyObject* obj)
1931 {
1932 unsigned int v;
1933 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1934 /*
1935 this is needed to make valgrind/purify happier.
1936 */
1937 memset((void*)&v, 0, sizeof(unsigned int));
1938 }
1939 return v;
1940 }
1941
1942
1943 SWIGINTERNSHORT int
1944 SWIG_Check_unsigned_SS_int(PyObject* obj)
1945 {
1946 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1947 }
1948
1949 static wxString Log_TimeStamp(){
1950 wxString msg;
1951 wxLog::TimeStamp(&msg);
1952 return msg;
1953 }
1954 static void wxLog_Destroy(wxLog *self){ delete self; }
1955 // Make somce wrappers that double any % signs so they are 'escaped'
1956 void wxPyLogFatalError(const wxString& msg)
1957 {
1958 wxString m(msg);
1959 m.Replace(wxT("%"), wxT("%%"));
1960 wxLogFatalError(m);
1961 }
1962
1963 void wxPyLogError(const wxString& msg)
1964 {
1965 wxString m(msg);
1966 m.Replace(wxT("%"), wxT("%%"));
1967 wxLogError(m);
1968 }
1969
1970 void wxPyLogWarning(const wxString& msg)
1971 {
1972 wxString m(msg);
1973 m.Replace(wxT("%"), wxT("%%"));
1974 wxLogWarning(m);
1975 }
1976
1977 void wxPyLogMessage(const wxString& msg)
1978 {
1979 wxString m(msg);
1980 m.Replace(wxT("%"), wxT("%%"));
1981 wxLogMessage(m);
1982 }
1983
1984 void wxPyLogInfo(const wxString& msg)
1985 {
1986 wxString m(msg);
1987 m.Replace(wxT("%"), wxT("%%"));
1988 wxLogInfo(m);
1989 }
1990
1991 void wxPyLogDebug(const wxString& msg)
1992 {
1993 wxString m(msg);
1994 m.Replace(wxT("%"), wxT("%%"));
1995 wxLogDebug(m);
1996 }
1997
1998 void wxPyLogVerbose(const wxString& msg)
1999 {
2000 wxString m(msg);
2001 m.Replace(wxT("%"), wxT("%%"));
2002 wxLogVerbose(m);
2003 }
2004
2005 void wxPyLogStatus(const wxString& msg)
2006 {
2007 wxString m(msg);
2008 m.Replace(wxT("%"), wxT("%%"));
2009 wxLogStatus(m);
2010 }
2011
2012 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2013 {
2014 wxString m(msg);
2015 m.Replace(wxT("%"), wxT("%%"));
2016 wxLogStatus(pFrame, m);
2017 }
2018
2019 void wxPyLogSysError(const wxString& msg)
2020 {
2021 wxString m(msg);
2022 m.Replace(wxT("%"), wxT("%%"));
2023 wxLogSysError(m);
2024 }
2025
2026 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2027 {
2028 wxString m(msg);
2029 m.Replace(wxT("%"), wxT("%%"));
2030 wxLogGeneric(level, m);
2031 }
2032
2033 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2034 {
2035 wxString m(msg);
2036 m.Replace(wxT("%"), wxT("%%"));
2037 wxLogTrace(mask, m);
2038 }
2039
2040 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2041 {
2042 wxString m(msg);
2043 m.Replace(wxT("%"), wxT("%%"));
2044 wxLogTrace(mask, m);
2045 }
2046
2047
2048
2049 // A wxLog class that can be derived from in wxPython
2050 class wxPyLog : public wxLog {
2051 public:
2052 wxPyLog() : wxLog() {}
2053
2054 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2055 bool found;
2056 bool blocked = wxPyBeginBlockThreads();
2057 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2058 PyObject* s = wx2PyString(szString);
2059 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2060 Py_DECREF(s);
2061 }
2062 wxPyEndBlockThreads(blocked);
2063 if (! found)
2064 wxLog::DoLog(level, szString, t);
2065 }
2066
2067 virtual void DoLogString(const wxChar *szString, time_t t) {
2068 bool found;
2069 bool blocked = wxPyBeginBlockThreads();
2070 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2071 PyObject* s = wx2PyString(szString);
2072 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2073 Py_DECREF(s);
2074 }
2075 wxPyEndBlockThreads(blocked);
2076 if (! found)
2077 wxLog::DoLogString(szString, t);
2078 }
2079
2080 PYPRIVATE;
2081 };
2082
2083
2084
2085
2086 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2087
2088
2089 #include <wx/joystick.h>
2090
2091
2092 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2093 // A C++ stub class for wxJoystick for platforms that don't have it.
2094 class wxJoystick : public wxObject {
2095 public:
2096 wxJoystick(int joystick = wxJOYSTICK1) {
2097 bool blocked = wxPyBeginBlockThreads();
2098 PyErr_SetString(PyExc_NotImplementedError,
2099 "wxJoystick is not available on this platform.");
2100 wxPyEndBlockThreads(blocked);
2101 }
2102 wxPoint GetPosition() { return wxPoint(-1,-1); }
2103 int GetZPosition() { return -1; }
2104 int GetButtonState() { return -1; }
2105 int GetPOVPosition() { return -1; }
2106 int GetPOVCTSPosition() { return -1; }
2107 int GetRudderPosition() { return -1; }
2108 int GetUPosition() { return -1; }
2109 int GetVPosition() { return -1; }
2110 int GetMovementThreshold() { return -1; }
2111 void SetMovementThreshold(int threshold) {}
2112
2113 bool IsOk(void) { return false; }
2114 int GetNumberJoysticks() { return -1; }
2115 int GetManufacturerId() { return -1; }
2116 int GetProductId() { return -1; }
2117 wxString GetProductName() { return wxEmptyString; }
2118 int GetXMin() { return -1; }
2119 int GetYMin() { return -1; }
2120 int GetZMin() { return -1; }
2121 int GetXMax() { return -1; }
2122 int GetYMax() { return -1; }
2123 int GetZMax() { return -1; }
2124 int GetNumberButtons() { return -1; }
2125 int GetNumberAxes() { return -1; }
2126 int GetMaxButtons() { return -1; }
2127 int GetMaxAxes() { return -1; }
2128 int GetPollingMin() { return -1; }
2129 int GetPollingMax() { return -1; }
2130 int GetRudderMin() { return -1; }
2131 int GetRudderMax() { return -1; }
2132 int GetUMin() { return -1; }
2133 int GetUMax() { return -1; }
2134 int GetVMin() { return -1; }
2135 int GetVMax() { return -1; }
2136
2137 bool HasRudder() { return false; }
2138 bool HasZ() { return false; }
2139 bool HasU() { return false; }
2140 bool HasV() { return false; }
2141 bool HasPOV() { return false; }
2142 bool HasPOV4Dir() { return false; }
2143 bool HasPOVCTS() { return false; }
2144
2145 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2146 bool ReleaseCapture() { return false; }
2147 };
2148 #endif
2149
2150
2151 #include <wx/sound.h>
2152
2153
2154 #if !wxUSE_SOUND
2155 // A C++ stub class for wxWave for platforms that don't have it.
2156 class wxSound : public wxObject
2157 {
2158 public:
2159 wxSound() {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(const wxString&/*, bool*/) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171 wxSound(int, const wxByte*) {
2172 bool blocked = wxPyBeginBlockThreads();
2173 PyErr_SetString(PyExc_NotImplementedError,
2174 "wxSound is not available on this platform.");
2175 wxPyEndBlockThreads(blocked);
2176 }
2177
2178 ~wxSound() {};
2179
2180 bool Create(const wxString&/*, bool*/) { return false; }
2181 bool Create(int, const wxByte*) { return false; };
2182 bool IsOk() { return false; };
2183 bool Play(unsigned) const { return false; }
2184 static bool Play(const wxString&, unsigned) { return false; }
2185 static void Stop() {}
2186 };
2187
2188 #endif
2189
2190 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2191 if (fileName.Length() == 0)
2192 return new wxSound;
2193 else
2194 return new wxSound(fileName);
2195 }
2196 static wxSound *new_wxSound(PyObject *data){
2197 unsigned char* buffer; int size;
2198 wxSound *sound = NULL;
2199
2200 bool blocked = wxPyBeginBlockThreads();
2201 if (!PyArg_Parse(data, "t#", &buffer, &size))
2202 goto done;
2203 sound = new wxSound(size, buffer);
2204 done:
2205 wxPyEndBlockThreads(blocked);
2206 return sound;
2207 }
2208 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2209 #ifndef __WXMAC__
2210 unsigned char* buffer;
2211 int size;
2212 bool rv = false;
2213
2214 bool blocked = wxPyBeginBlockThreads();
2215 if (!PyArg_Parse(data, "t#", &buffer, &size))
2216 goto done;
2217 rv = self->Create(size, buffer);
2218 done:
2219 wxPyEndBlockThreads(blocked);
2220 return rv;
2221 #else
2222 bool blocked = wxPyBeginBlockThreads();
2223 PyErr_SetString(PyExc_NotImplementedError,
2224 "Create from data is not available on this platform.");
2225 wxPyEndBlockThreads(blocked);
2226 return false;
2227 #endif
2228 }
2229
2230 #include <wx/mimetype.h>
2231
2232 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2233 wxString str;
2234 if (self->GetMimeType(&str))
2235 return wx2PyString(str);
2236 else
2237 RETURN_NONE();
2238 }
2239 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2240 wxArrayString arr;
2241 if (self->GetMimeTypes(arr))
2242 return wxArrayString2PyList_helper(arr);
2243 else
2244 RETURN_NONE();
2245 }
2246 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2247 wxArrayString arr;
2248 if (self->GetExtensions(arr))
2249 return wxArrayString2PyList_helper(arr);
2250 else
2251 RETURN_NONE();
2252 }
2253 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2254 wxIconLocation loc;
2255 if (self->GetIcon(&loc))
2256 return new wxIcon(loc);
2257 else
2258 return NULL;
2259 }
2260 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2261 wxIconLocation loc;
2262 if (self->GetIcon(&loc)) {
2263 wxString iconFile = loc.GetFileName();
2264 int iconIndex = -1;
2265
2266
2267
2268 // Make a tuple and put the values in it
2269 bool blocked = wxPyBeginBlockThreads();
2270 PyObject* tuple = PyTuple_New(3);
2271 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2272 wxT("wxIcon"), true));
2273 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2274 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2275 wxPyEndBlockThreads(blocked);
2276 return tuple;
2277 }
2278 else
2279 RETURN_NONE();
2280 }
2281 static PyObject *wxFileType_GetDescription(wxFileType *self){
2282 wxString str;
2283 if (self->GetDescription(&str))
2284 return wx2PyString(str);
2285 else
2286 RETURN_NONE();
2287 }
2288 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2289 wxString str;
2290 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2291 return wx2PyString(str);
2292 else
2293 RETURN_NONE();
2294 }
2295 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2296 wxString str;
2297 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2298 return wx2PyString(str);
2299 else
2300 RETURN_NONE();
2301 }
2302 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2303 wxArrayString verbs;
2304 wxArrayString commands;
2305 if (self->GetAllCommands(&verbs, &commands,
2306 wxFileType::MessageParameters(filename, mimetype))) {
2307 bool blocked = wxPyBeginBlockThreads();
2308 PyObject* tuple = PyTuple_New(2);
2309 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2310 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2311 wxPyEndBlockThreads(blocked);
2312 return tuple;
2313 }
2314 else
2315 RETURN_NONE();
2316 }
2317 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2318 return wxFileType::ExpandCommand(command,
2319 wxFileType::MessageParameters(filename, mimetype));
2320 }
2321 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2322 wxArrayString arr;
2323 self->EnumAllFileTypes(arr);
2324 return wxArrayString2PyList_helper(arr);
2325 }
2326
2327 #include <wx/artprov.h>
2328
2329 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2330 static const wxString wxPyART_MENU(wxART_MENU);
2331 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2332 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2333 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2334 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2335 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2336 static const wxString wxPyART_OTHER(wxART_OTHER);
2337 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2338 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2339 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2340 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2341 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2342 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2343 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2344 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2345 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2346 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2347 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2348 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2349 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2350 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2351 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2352 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2353 static const wxString wxPyART_PRINT(wxART_PRINT);
2354 static const wxString wxPyART_HELP(wxART_HELP);
2355 static const wxString wxPyART_TIP(wxART_TIP);
2356 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2357 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2358 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2359 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2360 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2361 static const wxString wxPyART_CDROM(wxART_CDROM);
2362 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2363 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2364 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2365 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2366 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2367 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2368 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2369 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2370 static const wxString wxPyART_ERROR(wxART_ERROR);
2371 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2372 static const wxString wxPyART_WARNING(wxART_WARNING);
2373 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2374 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2375 static const wxString wxPyART_COPY(wxART_COPY);
2376 static const wxString wxPyART_CUT(wxART_CUT);
2377 static const wxString wxPyART_PASTE(wxART_PASTE);
2378 static const wxString wxPyART_DELETE(wxART_DELETE);
2379 static const wxString wxPyART_UNDO(wxART_UNDO);
2380 static const wxString wxPyART_REDO(wxART_REDO);
2381 static const wxString wxPyART_QUIT(wxART_QUIT);
2382 static const wxString wxPyART_FIND(wxART_FIND);
2383 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2384 // Python aware wxArtProvider
2385 class wxPyArtProvider : public wxArtProvider {
2386 public:
2387
2388 virtual wxBitmap CreateBitmap(const wxArtID& id,
2389 const wxArtClient& client,
2390 const wxSize& size) {
2391 wxBitmap rval = wxNullBitmap;
2392 bool blocked = wxPyBeginBlockThreads();
2393 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2394 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2395 PyObject* ro;
2396 wxBitmap* ptr;
2397 PyObject* s1, *s2;
2398 s1 = wx2PyString(id);
2399 s2 = wx2PyString(client);
2400 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2401 Py_DECREF(so);
2402 Py_DECREF(s1);
2403 Py_DECREF(s2);
2404 if (ro) {
2405 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2406 rval = *ptr;
2407 Py_DECREF(ro);
2408 }
2409 }
2410 wxPyEndBlockThreads(blocked);
2411 return rval;
2412 }
2413
2414 PYPRIVATE;
2415 };
2416
2417 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2418
2419
2420
2421 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2422 PyObject* ret = PyTuple_New(3);
2423 if (ret) {
2424 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2425 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2426 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2427 }
2428 return ret;
2429 }
2430
2431 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2432 bool cont;
2433 long index = 0;
2434 wxString value;
2435
2436 cont = self->GetFirstGroup(value, index);
2437 return __EnumerationHelper(cont, value, index);
2438 }
2439 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2440 bool cont;
2441 wxString value;
2442
2443 cont = self->GetNextGroup(value, index);
2444 return __EnumerationHelper(cont, value, index);
2445 }
2446 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2447 bool cont;
2448 long index = 0;
2449 wxString value;
2450
2451 cont = self->GetFirstEntry(value, index);
2452 return __EnumerationHelper(cont, value, index);
2453 }
2454 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2455 bool cont;
2456 wxString value;
2457
2458 cont = self->GetNextEntry(value, index);
2459 return __EnumerationHelper(cont, value, index);
2460 }
2461 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2462 long rv;
2463 self->Read(key, &rv, defaultVal);
2464 return rv;
2465 }
2466
2467 SWIGINTERN int
2468 SWIG_AsVal_double(PyObject *obj, double* val)
2469 {
2470 if (PyNumber_Check(obj)) {
2471 if (val) *val = PyFloat_AsDouble(obj);
2472 return 1;
2473 }
2474 else {
2475 SWIG_type_error("number", obj);
2476 }
2477 return 0;
2478 }
2479
2480
2481 SWIGINTERNSHORT double
2482 SWIG_As_double(PyObject* obj)
2483 {
2484 double v;
2485 if (!SWIG_AsVal_double(obj, &v)) {
2486 /*
2487 this is needed to make valgrind/purify happier.
2488 */
2489 memset((void*)&v, 0, sizeof(double));
2490 }
2491 return v;
2492 }
2493
2494
2495 SWIGINTERNSHORT int
2496 SWIG_Check_double(PyObject* obj)
2497 {
2498 return SWIG_AsVal_double(obj, (double*)0);
2499 }
2500
2501 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2502 double rv;
2503 self->Read(key, &rv, defaultVal);
2504 return rv;
2505 }
2506
2507 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2508 #define SWIG_From_double PyFloat_FromDouble
2509 /*@@*/
2510
2511 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2512 bool rv;
2513 self->Read(key, &rv, defaultVal);
2514 return rv;
2515 }
2516
2517 #include <wx/datetime.h>
2518
2519 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2520 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2521
2522 #define LOCAL_TZ wxDateTime::Local
2523
2524 static PyObject *DateTime_GetAmPmStrings(){
2525 wxString am;
2526 wxString pm;
2527 wxDateTime::GetAmPmStrings(&am, &pm);
2528 bool blocked = wxPyBeginBlockThreads();
2529 PyObject* tup = PyTuple_New(2);
2530 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2531 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2532 wxPyEndBlockThreads(blocked);
2533 return tup;
2534 }
2535
2536 #if UINT_MAX < LONG_MAX
2537 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2538 #define SWIG_From_unsigned_SS_int SWIG_From_long
2539 /*@@*/
2540 #else
2541 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2542 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2543 /*@@*/
2544 #endif
2545
2546 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2547 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2548 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2549 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2550 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2551 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2552 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2553 return (*self < *other);
2554 }
2555 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2556 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2557 return (*self <= *other);
2558 }
2559 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2560 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2561 return (*self > *other);
2562 }
2563 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2564 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2565 return (*self >= *other);
2566 }
2567 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2568 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2569 return (*self == *other);
2570 }
2571 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2572 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2573 return (*self != *other);
2574 }
2575 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2576 const wxChar* rv;
2577 const wxChar* _date = date;
2578 rv = self->ParseRfc822Date(_date);
2579 if (rv == NULL) return -1;
2580 return rv - _date;
2581 }
2582 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2583 const wxChar* rv;
2584 const wxChar* _date = date;
2585 rv = self->ParseFormat(_date, format, dateDef);
2586 if (rv == NULL) return -1;
2587 return rv - _date;
2588 }
2589 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2590 const wxChar* rv;
2591 const wxChar* _datetime = datetime;
2592 rv = self->ParseDateTime(_datetime);
2593 if (rv == NULL) return -1;
2594 return rv - _datetime;
2595 }
2596 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2597 const wxChar* rv;
2598 const wxChar* _date = date;
2599 rv = self->ParseDate(_date);
2600 if (rv == NULL) return -1;
2601 return rv - _date;
2602 }
2603 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2604 const wxChar* rv;
2605 const wxChar* _time = time;
2606 rv = self->ParseTime(_time);
2607 if (rv == NULL) return -1;
2608 return rv - _time;
2609 }
2610 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2611 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2612 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2613 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2614 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2615 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2616 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2617 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2618 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2620 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2621 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2622 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2623 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2624 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2625 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2626
2627 #include <wx/dataobj.h>
2628
2629 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2630 size_t count = self->GetFormatCount(dir);
2631 wxDataFormat* formats = new wxDataFormat[count];
2632 self->GetAllFormats(formats, dir);
2633
2634 bool blocked = wxPyBeginBlockThreads();
2635 PyObject* list = PyList_New(count);
2636 for (size_t i=0; i<count; i++) {
2637 wxDataFormat* format = new wxDataFormat(formats[i]);
2638 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2639 PyList_Append(list, obj);
2640 Py_DECREF(obj);
2641 }
2642 wxPyEndBlockThreads(blocked);
2643 delete [] formats;
2644 return list;
2645 }
2646 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2647 PyObject* rval = NULL;
2648 size_t size = self->GetDataSize(format);
2649 bool blocked = wxPyBeginBlockThreads();
2650 if (size) {
2651 char* buf = new char[size];
2652 if (self->GetDataHere(format, buf))
2653 rval = PyString_FromStringAndSize(buf, size);
2654 delete [] buf;
2655 }
2656 if (! rval) {
2657 rval = Py_None;
2658 Py_INCREF(rval);
2659 }
2660 wxPyEndBlockThreads(blocked);
2661 return rval;
2662 }
2663 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2664 bool rval;
2665 bool blocked = wxPyBeginBlockThreads();
2666 if (PyString_Check(data)) {
2667 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2668 }
2669 else {
2670 // raise a TypeError if not a string
2671 PyErr_SetString(PyExc_TypeError, "String expected.");
2672 rval = false;
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2678 PyObject* rval = NULL;
2679 size_t size = self->GetDataSize();
2680 bool blocked = wxPyBeginBlockThreads();
2681 if (size) {
2682 char* buf = new char[size];
2683 if (self->GetDataHere(buf))
2684 rval = PyString_FromStringAndSize(buf, size);
2685 delete [] buf;
2686 }
2687 if (! rval) {
2688 rval = Py_None;
2689 Py_INCREF(rval);
2690 }
2691 wxPyEndBlockThreads(blocked);
2692 return rval;
2693 }
2694 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2695 bool rval;
2696 bool blocked = wxPyBeginBlockThreads();
2697 if (PyString_Check(data)) {
2698 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2699 }
2700 else {
2701 // raise a TypeError if not a string
2702 PyErr_SetString(PyExc_TypeError, "String expected.");
2703 rval = false;
2704 }
2705 wxPyEndBlockThreads(blocked);
2706 return rval;
2707 }
2708 // Create a new class for wxPython to use
2709 class wxPyDataObjectSimple : public wxDataObjectSimple {
2710 public:
2711 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2712 : wxDataObjectSimple(format) {}
2713
2714 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2715 bool GetDataHere(void *buf) const;
2716 bool SetData(size_t len, const void *buf) const;
2717 PYPRIVATE;
2718 };
2719
2720 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2721
2722 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2723 // We need to get the data for this object and write it to buf. I think
2724 // the best way to do this for wxPython is to have the Python method
2725 // return either a string or None and then act appropriately with the
2726 // C++ version.
2727
2728 bool rval = false;
2729 bool blocked = wxPyBeginBlockThreads();
2730 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2731 PyObject* ro;
2732 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2733 if (ro) {
2734 rval = (ro != Py_None && PyString_Check(ro));
2735 if (rval)
2736 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2737 Py_DECREF(ro);
2738 }
2739 }
2740 wxPyEndBlockThreads(blocked);
2741 return rval;
2742 }
2743
2744 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2745 // For this one we simply need to make a string from buf and len
2746 // and send it to the Python method.
2747 bool rval = false;
2748 bool blocked = wxPyBeginBlockThreads();
2749 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2750 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2751 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2752 Py_DECREF(data);
2753 }
2754 wxPyEndBlockThreads(blocked);
2755 return rval;
2756 }
2757
2758 // Create a new class for wxPython to use
2759 class wxPyTextDataObject : public wxTextDataObject {
2760 public:
2761 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2762 : wxTextDataObject(text) {}
2763
2764 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2765 DEC_PYCALLBACK_STRING__const(GetText);
2766 DEC_PYCALLBACK__STRING(SetText);
2767 PYPRIVATE;
2768 };
2769
2770 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2771 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2772 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2773
2774
2775 // Create a new class for wxPython to use
2776 class wxPyBitmapDataObject : public wxBitmapDataObject {
2777 public:
2778 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2779 : wxBitmapDataObject(bitmap) {}
2780
2781 wxBitmap GetBitmap() const;
2782 void SetBitmap(const wxBitmap& bitmap);
2783 PYPRIVATE;
2784 };
2785
2786 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2787 wxBitmap* rval = &wxNullBitmap;
2788 bool blocked = wxPyBeginBlockThreads();
2789 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2790 PyObject* ro;
2791 wxBitmap* ptr;
2792 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2793 if (ro) {
2794 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2795 rval = ptr;
2796 Py_DECREF(ro);
2797 }
2798 }
2799 wxPyEndBlockThreads(blocked);
2800 return *rval;
2801 }
2802
2803 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2804 bool blocked = wxPyBeginBlockThreads();
2805 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2806 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2807 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2808 Py_DECREF(bo);
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 }
2812
2813 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2814 return new wxCustomDataObject(wxDataFormat(formatName));
2815 }
2816 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2817 bool rval;
2818 bool blocked = wxPyBeginBlockThreads();
2819 if (PyString_Check(data)) {
2820 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2821 }
2822 else {
2823 // raise a TypeError if not a string
2824 PyErr_SetString(PyExc_TypeError, "String expected.");
2825 rval = false;
2826 }
2827 wxPyEndBlockThreads(blocked);
2828 return rval;
2829 }
2830 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2831 PyObject* obj;
2832 bool blocked = wxPyBeginBlockThreads();
2833 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2834 wxPyEndBlockThreads(blocked);
2835 return obj;
2836 }
2837
2838 class wxMetafileDataObject : public wxDataObjectSimple
2839 {
2840 public:
2841 wxMetafileDataObject() { wxPyRaiseNotImplemented(); }
2842 };
2843
2844
2845 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2846
2847
2848 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2849 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2850 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2851 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2852 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2853
2854
2855 class wxPyTextDropTarget : public wxTextDropTarget {
2856 public:
2857 wxPyTextDropTarget() {}
2858
2859 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2860
2861 DEC_PYCALLBACK__(OnLeave);
2862 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2863 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2864 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2865 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2866
2867 PYPRIVATE;
2868 };
2869
2870 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2871 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2872 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2873 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2874 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2875 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2876
2877
2878
2879 class wxPyFileDropTarget : public wxFileDropTarget {
2880 public:
2881 wxPyFileDropTarget() {}
2882
2883 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2884
2885 DEC_PYCALLBACK__(OnLeave);
2886 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2887 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2888 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2889 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2890
2891 PYPRIVATE;
2892 };
2893
2894 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2895 const wxArrayString& filenames) {
2896 bool rval = false;
2897 bool blocked = wxPyBeginBlockThreads();
2898 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2899 PyObject* list = wxArrayString2PyList_helper(filenames);
2900 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2901 Py_DECREF(list);
2902 }
2903 wxPyEndBlockThreads(blocked);
2904 return rval;
2905 }
2906
2907
2908
2909 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2910 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2911 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2912 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2913 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2914
2915
2916
2917
2918 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2919
2920 #include <wx/display.h>
2921
2922 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2923 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2924
2925 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2926 #if !wxUSE_DISPLAY
2927 #include <wx/dynarray.h>
2928 #include <wx/vidmode.h>
2929
2930 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2931 #include "wx/arrimpl.cpp"
2932 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2933 const wxVideoMode wxDefaultVideoMode;
2934
2935 class wxDisplay
2936 {
2937 public:
2938 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2939 ~wxDisplay() {}
2940
2941 static size_t GetCount()
2942 { wxPyRaiseNotImplemented(); return 0; }
2943
2944 static int GetFromPoint(const wxPoint& pt)
2945 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2946 static int GetFromWindow(wxWindow *window)
2947 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2948
2949 virtual bool IsOk() const { return false; }
2950 virtual wxRect GetGeometry() const { wxRect r; return r; }
2951 virtual wxString GetName() const { return wxEmptyString; }
2952 bool IsPrimary() const { return false; }
2953
2954 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2955 { wxArrayVideoModes a; return a; }
2956
2957 virtual wxVideoMode GetCurrentMode() const
2958 { return wxDefaultVideoMode; }
2959
2960 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2961 { return false; }
2962
2963 void ResetMode() {}
2964 };
2965 #endif
2966
2967 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2968 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2969 PyObject* pyList = NULL;
2970 wxArrayVideoModes arr = self->GetModes(mode);
2971 bool blocked = wxPyBeginBlockThreads();
2972 pyList = PyList_New(0);
2973 for (int i=0; i < arr.GetCount(); i++) {
2974 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2975 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2976 PyList_Append(pyList, pyObj);
2977 Py_DECREF(pyObj);
2978 }
2979 wxPyEndBlockThreads(blocked);
2980 return pyList;
2981 }
2982
2983 #include <wx/stdpaths.h>
2984
2985 static wxStandardPaths *StandardPaths_Get(){
2986 return (wxStandardPaths*) &wxStandardPaths::Get();
2987 }
2988 #ifdef __cplusplus
2989 extern "C" {
2990 #endif
2991 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2992 PyObject *resultobj;
2993 wxSystemColour arg1 ;
2994 wxColour result;
2995 PyObject * obj0 = 0 ;
2996 char *kwnames[] = {
2997 (char *) "index", NULL
2998 };
2999
3000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
3001 {
3002 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
3003 if (SWIG_arg_fail(1)) SWIG_fail;
3004 }
3005 {
3006 if (!wxPyCheckForApp()) SWIG_fail;
3007 PyThreadState* __tstate = wxPyBeginAllowThreads();
3008 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3009
3010 wxPyEndAllowThreads(__tstate);
3011 if (PyErr_Occurred()) SWIG_fail;
3012 }
3013 {
3014 wxColour * resultptr;
3015 resultptr = new wxColour((wxColour &)(result));
3016 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3017 }
3018 return resultobj;
3019 fail:
3020 return NULL;
3021 }
3022
3023
3024 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3025 PyObject *resultobj;
3026 wxSystemFont arg1 ;
3027 wxFont result;
3028 PyObject * obj0 = 0 ;
3029 char *kwnames[] = {
3030 (char *) "index", NULL
3031 };
3032
3033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3034 {
3035 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3036 if (SWIG_arg_fail(1)) SWIG_fail;
3037 }
3038 {
3039 if (!wxPyCheckForApp()) SWIG_fail;
3040 PyThreadState* __tstate = wxPyBeginAllowThreads();
3041 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3042
3043 wxPyEndAllowThreads(__tstate);
3044 if (PyErr_Occurred()) SWIG_fail;
3045 }
3046 {
3047 wxFont * resultptr;
3048 resultptr = new wxFont((wxFont &)(result));
3049 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3050 }
3051 return resultobj;
3052 fail:
3053 return NULL;
3054 }
3055
3056
3057 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3058 PyObject *resultobj;
3059 wxSystemMetric arg1 ;
3060 int result;
3061 PyObject * obj0 = 0 ;
3062 char *kwnames[] = {
3063 (char *) "index", NULL
3064 };
3065
3066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3067 {
3068 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3069 if (SWIG_arg_fail(1)) SWIG_fail;
3070 }
3071 {
3072 if (!wxPyCheckForApp()) SWIG_fail;
3073 PyThreadState* __tstate = wxPyBeginAllowThreads();
3074 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3075
3076 wxPyEndAllowThreads(__tstate);
3077 if (PyErr_Occurred()) SWIG_fail;
3078 }
3079 {
3080 resultobj = SWIG_From_int((int)(result));
3081 }
3082 return resultobj;
3083 fail:
3084 return NULL;
3085 }
3086
3087
3088 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3089 PyObject *resultobj;
3090 wxSystemFeature arg1 ;
3091 bool result;
3092 PyObject * obj0 = 0 ;
3093 char *kwnames[] = {
3094 (char *) "index", NULL
3095 };
3096
3097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3098 {
3099 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3100 if (SWIG_arg_fail(1)) SWIG_fail;
3101 }
3102 {
3103 if (!wxPyCheckForApp()) SWIG_fail;
3104 PyThreadState* __tstate = wxPyBeginAllowThreads();
3105 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3106
3107 wxPyEndAllowThreads(__tstate);
3108 if (PyErr_Occurred()) SWIG_fail;
3109 }
3110 {
3111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3112 }
3113 return resultobj;
3114 fail:
3115 return NULL;
3116 }
3117
3118
3119 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3120 PyObject *resultobj;
3121 wxSystemScreenType result;
3122 char *kwnames[] = {
3123 NULL
3124 };
3125
3126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3127 {
3128 if (!wxPyCheckForApp()) SWIG_fail;
3129 PyThreadState* __tstate = wxPyBeginAllowThreads();
3130 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3131
3132 wxPyEndAllowThreads(__tstate);
3133 if (PyErr_Occurred()) SWIG_fail;
3134 }
3135 resultobj = SWIG_From_int((result));
3136 return resultobj;
3137 fail:
3138 return NULL;
3139 }
3140
3141
3142 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3143 PyObject *resultobj;
3144 wxSystemScreenType arg1 ;
3145 PyObject * obj0 = 0 ;
3146 char *kwnames[] = {
3147 (char *) "screen", NULL
3148 };
3149
3150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3151 {
3152 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3153 if (SWIG_arg_fail(1)) SWIG_fail;
3154 }
3155 {
3156 if (!wxPyCheckForApp()) SWIG_fail;
3157 PyThreadState* __tstate = wxPyBeginAllowThreads();
3158 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3159
3160 wxPyEndAllowThreads(__tstate);
3161 if (PyErr_Occurred()) SWIG_fail;
3162 }
3163 Py_INCREF(Py_None); resultobj = Py_None;
3164 return resultobj;
3165 fail:
3166 return NULL;
3167 }
3168
3169
3170 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3171 PyObject *obj;
3172 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3173 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3174 Py_INCREF(obj);
3175 return Py_BuildValue((char *)"");
3176 }
3177 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3178 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3179 return 1;
3180 }
3181
3182
3183 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3184 PyObject *pyobj;
3185
3186 {
3187 #if wxUSE_UNICODE
3188 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3189 #else
3190 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3191 #endif
3192 }
3193 return pyobj;
3194 }
3195
3196
3197 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3198 PyObject *resultobj;
3199 wxSystemOptions *result;
3200 char *kwnames[] = {
3201 NULL
3202 };
3203
3204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3205 {
3206 PyThreadState* __tstate = wxPyBeginAllowThreads();
3207 result = (wxSystemOptions *)new wxSystemOptions();
3208
3209 wxPyEndAllowThreads(__tstate);
3210 if (PyErr_Occurred()) SWIG_fail;
3211 }
3212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3213 return resultobj;
3214 fail:
3215 return NULL;
3216 }
3217
3218
3219 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3220 PyObject *resultobj;
3221 wxString *arg1 = 0 ;
3222 wxString *arg2 = 0 ;
3223 bool temp1 = false ;
3224 bool temp2 = false ;
3225 PyObject * obj0 = 0 ;
3226 PyObject * obj1 = 0 ;
3227 char *kwnames[] = {
3228 (char *) "name",(char *) "value", NULL
3229 };
3230
3231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3232 {
3233 arg1 = wxString_in_helper(obj0);
3234 if (arg1 == NULL) SWIG_fail;
3235 temp1 = true;
3236 }
3237 {
3238 arg2 = wxString_in_helper(obj1);
3239 if (arg2 == NULL) SWIG_fail;
3240 temp2 = true;
3241 }
3242 {
3243 PyThreadState* __tstate = wxPyBeginAllowThreads();
3244 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3245
3246 wxPyEndAllowThreads(__tstate);
3247 if (PyErr_Occurred()) SWIG_fail;
3248 }
3249 Py_INCREF(Py_None); resultobj = Py_None;
3250 {
3251 if (temp1)
3252 delete arg1;
3253 }
3254 {
3255 if (temp2)
3256 delete arg2;
3257 }
3258 return resultobj;
3259 fail:
3260 {
3261 if (temp1)
3262 delete arg1;
3263 }
3264 {
3265 if (temp2)
3266 delete arg2;
3267 }
3268 return NULL;
3269 }
3270
3271
3272 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3273 PyObject *resultobj;
3274 wxString *arg1 = 0 ;
3275 int arg2 ;
3276 bool temp1 = false ;
3277 PyObject * obj0 = 0 ;
3278 PyObject * obj1 = 0 ;
3279 char *kwnames[] = {
3280 (char *) "name",(char *) "value", NULL
3281 };
3282
3283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3284 {
3285 arg1 = wxString_in_helper(obj0);
3286 if (arg1 == NULL) SWIG_fail;
3287 temp1 = true;
3288 }
3289 {
3290 arg2 = (int)(SWIG_As_int(obj1));
3291 if (SWIG_arg_fail(2)) SWIG_fail;
3292 }
3293 {
3294 PyThreadState* __tstate = wxPyBeginAllowThreads();
3295 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3296
3297 wxPyEndAllowThreads(__tstate);
3298 if (PyErr_Occurred()) SWIG_fail;
3299 }
3300 Py_INCREF(Py_None); resultobj = Py_None;
3301 {
3302 if (temp1)
3303 delete arg1;
3304 }
3305 return resultobj;
3306 fail:
3307 {
3308 if (temp1)
3309 delete arg1;
3310 }
3311 return NULL;
3312 }
3313
3314
3315 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3316 PyObject *resultobj;
3317 wxString *arg1 = 0 ;
3318 wxString result;
3319 bool temp1 = false ;
3320 PyObject * obj0 = 0 ;
3321 char *kwnames[] = {
3322 (char *) "name", NULL
3323 };
3324
3325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3326 {
3327 arg1 = wxString_in_helper(obj0);
3328 if (arg1 == NULL) SWIG_fail;
3329 temp1 = true;
3330 }
3331 {
3332 PyThreadState* __tstate = wxPyBeginAllowThreads();
3333 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3334
3335 wxPyEndAllowThreads(__tstate);
3336 if (PyErr_Occurred()) SWIG_fail;
3337 }
3338 {
3339 #if wxUSE_UNICODE
3340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3341 #else
3342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3343 #endif
3344 }
3345 {
3346 if (temp1)
3347 delete arg1;
3348 }
3349 return resultobj;
3350 fail:
3351 {
3352 if (temp1)
3353 delete arg1;
3354 }
3355 return NULL;
3356 }
3357
3358
3359 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3360 PyObject *resultobj;
3361 wxString *arg1 = 0 ;
3362 int result;
3363 bool temp1 = false ;
3364 PyObject * obj0 = 0 ;
3365 char *kwnames[] = {
3366 (char *) "name", NULL
3367 };
3368
3369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3370 {
3371 arg1 = wxString_in_helper(obj0);
3372 if (arg1 == NULL) SWIG_fail;
3373 temp1 = true;
3374 }
3375 {
3376 PyThreadState* __tstate = wxPyBeginAllowThreads();
3377 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3378
3379 wxPyEndAllowThreads(__tstate);
3380 if (PyErr_Occurred()) SWIG_fail;
3381 }
3382 {
3383 resultobj = SWIG_From_int((int)(result));
3384 }
3385 {
3386 if (temp1)
3387 delete arg1;
3388 }
3389 return resultobj;
3390 fail:
3391 {
3392 if (temp1)
3393 delete arg1;
3394 }
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 wxString *arg1 = 0 ;
3402 bool result;
3403 bool temp1 = false ;
3404 PyObject * obj0 = 0 ;
3405 char *kwnames[] = {
3406 (char *) "name", NULL
3407 };
3408
3409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3410 {
3411 arg1 = wxString_in_helper(obj0);
3412 if (arg1 == NULL) SWIG_fail;
3413 temp1 = true;
3414 }
3415 {
3416 PyThreadState* __tstate = wxPyBeginAllowThreads();
3417 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3418
3419 wxPyEndAllowThreads(__tstate);
3420 if (PyErr_Occurred()) SWIG_fail;
3421 }
3422 {
3423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3424 }
3425 {
3426 if (temp1)
3427 delete arg1;
3428 }
3429 return resultobj;
3430 fail:
3431 {
3432 if (temp1)
3433 delete arg1;
3434 }
3435 return NULL;
3436 }
3437
3438
3439 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3440 PyObject *obj;
3441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3442 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3443 Py_INCREF(obj);
3444 return Py_BuildValue((char *)"");
3445 }
3446 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3447 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3448 return 1;
3449 }
3450
3451
3452 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3453 PyObject *pyobj;
3454
3455 {
3456 #if wxUSE_UNICODE
3457 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3458 #else
3459 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3460 #endif
3461 }
3462 return pyobj;
3463 }
3464
3465
3466 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3467 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3468 return 1;
3469 }
3470
3471
3472 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3473 PyObject *pyobj;
3474
3475 {
3476 #if wxUSE_UNICODE
3477 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3478 #else
3479 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3480 #endif
3481 }
3482 return pyobj;
3483 }
3484
3485
3486 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3487 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3488 return 1;
3489 }
3490
3491
3492 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3493 PyObject *pyobj;
3494
3495 {
3496 #if wxUSE_UNICODE
3497 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3498 #else
3499 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3500 #endif
3501 }
3502 return pyobj;
3503 }
3504
3505
3506 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3507 PyObject *resultobj;
3508 long result;
3509 char *kwnames[] = {
3510 NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3514 {
3515 PyThreadState* __tstate = wxPyBeginAllowThreads();
3516 result = (long)wxNewId();
3517
3518 wxPyEndAllowThreads(__tstate);
3519 if (PyErr_Occurred()) SWIG_fail;
3520 }
3521 {
3522 resultobj = SWIG_From_long((long)(result));
3523 }
3524 return resultobj;
3525 fail:
3526 return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3531 PyObject *resultobj;
3532 long arg1 ;
3533 PyObject * obj0 = 0 ;
3534 char *kwnames[] = {
3535 (char *) "id", NULL
3536 };
3537
3538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3539 {
3540 arg1 = (long)(SWIG_As_long(obj0));
3541 if (SWIG_arg_fail(1)) SWIG_fail;
3542 }
3543 {
3544 PyThreadState* __tstate = wxPyBeginAllowThreads();
3545 wxRegisterId(arg1);
3546
3547 wxPyEndAllowThreads(__tstate);
3548 if (PyErr_Occurred()) SWIG_fail;
3549 }
3550 Py_INCREF(Py_None); resultobj = Py_None;
3551 return resultobj;
3552 fail:
3553 return NULL;
3554 }
3555
3556
3557 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3558 PyObject *resultobj;
3559 long result;
3560 char *kwnames[] = {
3561 NULL
3562 };
3563
3564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3565 {
3566 PyThreadState* __tstate = wxPyBeginAllowThreads();
3567 result = (long)wxGetCurrentId();
3568
3569 wxPyEndAllowThreads(__tstate);
3570 if (PyErr_Occurred()) SWIG_fail;
3571 }
3572 {
3573 resultobj = SWIG_From_long((long)(result));
3574 }
3575 return resultobj;
3576 fail:
3577 return NULL;
3578 }
3579
3580
3581 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3582 PyObject *resultobj;
3583 int arg1 ;
3584 bool result;
3585 PyObject * obj0 = 0 ;
3586 char *kwnames[] = {
3587 (char *) "id", NULL
3588 };
3589
3590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3591 {
3592 arg1 = (int)(SWIG_As_int(obj0));
3593 if (SWIG_arg_fail(1)) SWIG_fail;
3594 }
3595 {
3596 PyThreadState* __tstate = wxPyBeginAllowThreads();
3597 result = (bool)wxIsStockID(arg1);
3598
3599 wxPyEndAllowThreads(__tstate);
3600 if (PyErr_Occurred()) SWIG_fail;
3601 }
3602 {
3603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3604 }
3605 return resultobj;
3606 fail:
3607 return NULL;
3608 }
3609
3610
3611 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3612 PyObject *resultobj;
3613 int arg1 ;
3614 wxString *arg2 = 0 ;
3615 bool result;
3616 bool temp2 = false ;
3617 PyObject * obj0 = 0 ;
3618 PyObject * obj1 = 0 ;
3619 char *kwnames[] = {
3620 (char *) "id",(char *) "label", NULL
3621 };
3622
3623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3624 {
3625 arg1 = (int)(SWIG_As_int(obj0));
3626 if (SWIG_arg_fail(1)) SWIG_fail;
3627 }
3628 {
3629 arg2 = wxString_in_helper(obj1);
3630 if (arg2 == NULL) SWIG_fail;
3631 temp2 = true;
3632 }
3633 {
3634 PyThreadState* __tstate = wxPyBeginAllowThreads();
3635 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3636
3637 wxPyEndAllowThreads(__tstate);
3638 if (PyErr_Occurred()) SWIG_fail;
3639 }
3640 {
3641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3642 }
3643 {
3644 if (temp2)
3645 delete arg2;
3646 }
3647 return resultobj;
3648 fail:
3649 {
3650 if (temp2)
3651 delete arg2;
3652 }
3653 return NULL;
3654 }
3655
3656
3657 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3658 PyObject *resultobj;
3659 int arg1 ;
3660 bool arg2 = (bool) true ;
3661 wxString arg3 = (wxString) wxPyEmptyString ;
3662 wxString result;
3663 PyObject * obj0 = 0 ;
3664 PyObject * obj1 = 0 ;
3665 PyObject * obj2 = 0 ;
3666 char *kwnames[] = {
3667 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3668 };
3669
3670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3671 {
3672 arg1 = (int)(SWIG_As_int(obj0));
3673 if (SWIG_arg_fail(1)) SWIG_fail;
3674 }
3675 if (obj1) {
3676 {
3677 arg2 = (bool)(SWIG_As_bool(obj1));
3678 if (SWIG_arg_fail(2)) SWIG_fail;
3679 }
3680 }
3681 if (obj2) {
3682 {
3683 wxString* sptr = wxString_in_helper(obj2);
3684 if (sptr == NULL) SWIG_fail;
3685 arg3 = *sptr;
3686 delete sptr;
3687 }
3688 }
3689 {
3690 PyThreadState* __tstate = wxPyBeginAllowThreads();
3691 result = wxGetStockLabel(arg1,arg2,arg3);
3692
3693 wxPyEndAllowThreads(__tstate);
3694 if (PyErr_Occurred()) SWIG_fail;
3695 }
3696 {
3697 #if wxUSE_UNICODE
3698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3699 #else
3700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3701 #endif
3702 }
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj;
3711 char *kwnames[] = {
3712 NULL
3713 };
3714
3715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3716 {
3717 if (!wxPyCheckForApp()) SWIG_fail;
3718 PyThreadState* __tstate = wxPyBeginAllowThreads();
3719 wxBell();
3720
3721 wxPyEndAllowThreads(__tstate);
3722 if (PyErr_Occurred()) SWIG_fail;
3723 }
3724 Py_INCREF(Py_None); resultobj = Py_None;
3725 return resultobj;
3726 fail:
3727 return NULL;
3728 }
3729
3730
3731 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3732 PyObject *resultobj;
3733 char *kwnames[] = {
3734 NULL
3735 };
3736
3737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3738 {
3739 if (!wxPyCheckForApp()) SWIG_fail;
3740 PyThreadState* __tstate = wxPyBeginAllowThreads();
3741 wxEndBusyCursor();
3742
3743 wxPyEndAllowThreads(__tstate);
3744 if (PyErr_Occurred()) SWIG_fail;
3745 }
3746 Py_INCREF(Py_None); resultobj = Py_None;
3747 return resultobj;
3748 fail:
3749 return NULL;
3750 }
3751
3752
3753 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3754 PyObject *resultobj;
3755 bool arg1 = (bool) true ;
3756 long result;
3757 PyObject * obj0 = 0 ;
3758 char *kwnames[] = {
3759 (char *) "resetTimer", NULL
3760 };
3761
3762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3763 if (obj0) {
3764 {
3765 arg1 = (bool)(SWIG_As_bool(obj0));
3766 if (SWIG_arg_fail(1)) SWIG_fail;
3767 }
3768 }
3769 {
3770 PyThreadState* __tstate = wxPyBeginAllowThreads();
3771 result = (long)wxGetElapsedTime(arg1);
3772
3773 wxPyEndAllowThreads(__tstate);
3774 if (PyErr_Occurred()) SWIG_fail;
3775 }
3776 {
3777 resultobj = SWIG_From_long((long)(result));
3778 }
3779 return resultobj;
3780 fail:
3781 return NULL;
3782 }
3783
3784
3785 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3786 PyObject *resultobj;
3787 int *arg1 = (int *) 0 ;
3788 int *arg2 = (int *) 0 ;
3789 int temp1 ;
3790 int res1 = 0 ;
3791 int temp2 ;
3792 int res2 = 0 ;
3793 char *kwnames[] = {
3794 NULL
3795 };
3796
3797 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3800 {
3801 if (!wxPyCheckForApp()) SWIG_fail;
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 wxGetMousePosition(arg1,arg2);
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 Py_INCREF(Py_None); resultobj = Py_None;
3809 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3810 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3811 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3812 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3813 return resultobj;
3814 fail:
3815 return NULL;
3816 }
3817
3818
3819 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3820 PyObject *resultobj;
3821 bool result;
3822 char *kwnames[] = {
3823 NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3827 {
3828 PyThreadState* __tstate = wxPyBeginAllowThreads();
3829 result = (bool)wxIsBusy();
3830
3831 wxPyEndAllowThreads(__tstate);
3832 if (PyErr_Occurred()) SWIG_fail;
3833 }
3834 {
3835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3836 }
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj;
3845 wxString result;
3846 char *kwnames[] = {
3847 NULL
3848 };
3849
3850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3851 {
3852 PyThreadState* __tstate = wxPyBeginAllowThreads();
3853 result = wxNow();
3854
3855 wxPyEndAllowThreads(__tstate);
3856 if (PyErr_Occurred()) SWIG_fail;
3857 }
3858 {
3859 #if wxUSE_UNICODE
3860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3861 #else
3862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3863 #endif
3864 }
3865 return resultobj;
3866 fail:
3867 return NULL;
3868 }
3869
3870
3871 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3872 PyObject *resultobj;
3873 wxString const &arg1_defvalue = wxPyEmptyString ;
3874 wxString *arg1 = (wxString *) &arg1_defvalue ;
3875 bool result;
3876 bool temp1 = false ;
3877 PyObject * obj0 = 0 ;
3878 char *kwnames[] = {
3879 (char *) "command", NULL
3880 };
3881
3882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3883 if (obj0) {
3884 {
3885 arg1 = wxString_in_helper(obj0);
3886 if (arg1 == NULL) SWIG_fail;
3887 temp1 = true;
3888 }
3889 }
3890 {
3891 PyThreadState* __tstate = wxPyBeginAllowThreads();
3892 result = (bool)wxShell((wxString const &)*arg1);
3893
3894 wxPyEndAllowThreads(__tstate);
3895 if (PyErr_Occurred()) SWIG_fail;
3896 }
3897 {
3898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3899 }
3900 {
3901 if (temp1)
3902 delete arg1;
3903 }
3904 return resultobj;
3905 fail:
3906 {
3907 if (temp1)
3908 delete arg1;
3909 }
3910 return NULL;
3911 }
3912
3913
3914 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3915 PyObject *resultobj;
3916 char *kwnames[] = {
3917 NULL
3918 };
3919
3920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3921 {
3922 PyThreadState* __tstate = wxPyBeginAllowThreads();
3923 wxStartTimer();
3924
3925 wxPyEndAllowThreads(__tstate);
3926 if (PyErr_Occurred()) SWIG_fail;
3927 }
3928 Py_INCREF(Py_None); resultobj = Py_None;
3929 return resultobj;
3930 fail:
3931 return NULL;
3932 }
3933
3934
3935 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3936 PyObject *resultobj;
3937 int *arg1 = (int *) 0 ;
3938 int *arg2 = (int *) 0 ;
3939 int result;
3940 int temp1 ;
3941 int res1 = 0 ;
3942 int temp2 ;
3943 int res2 = 0 ;
3944 char *kwnames[] = {
3945 NULL
3946 };
3947
3948 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3949 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3951 {
3952 PyThreadState* __tstate = wxPyBeginAllowThreads();
3953 result = (int)wxGetOsVersion(arg1,arg2);
3954
3955 wxPyEndAllowThreads(__tstate);
3956 if (PyErr_Occurred()) SWIG_fail;
3957 }
3958 {
3959 resultobj = SWIG_From_int((int)(result));
3960 }
3961 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3962 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3963 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3964 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3965 return resultobj;
3966 fail:
3967 return NULL;
3968 }
3969
3970
3971 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3972 PyObject *resultobj;
3973 wxString result;
3974 char *kwnames[] = {
3975 NULL
3976 };
3977
3978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3979 {
3980 PyThreadState* __tstate = wxPyBeginAllowThreads();
3981 result = wxGetOsDescription();
3982
3983 wxPyEndAllowThreads(__tstate);
3984 if (PyErr_Occurred()) SWIG_fail;
3985 }
3986 {
3987 #if wxUSE_UNICODE
3988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3989 #else
3990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3991 #endif
3992 }
3993 return resultobj;
3994 fail:
3995 return NULL;
3996 }
3997
3998
3999 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
4000 PyObject *resultobj;
4001 long result;
4002 char *kwnames[] = {
4003 NULL
4004 };
4005
4006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
4007 {
4008 PyThreadState* __tstate = wxPyBeginAllowThreads();
4009 result = (long)wxGetFreeMemory();
4010
4011 wxPyEndAllowThreads(__tstate);
4012 if (PyErr_Occurred()) SWIG_fail;
4013 }
4014 {
4015 resultobj = SWIG_From_long((long)(result));
4016 }
4017 return resultobj;
4018 fail:
4019 return NULL;
4020 }
4021
4022
4023 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4024 PyObject *resultobj;
4025 wxShutdownFlags arg1 ;
4026 bool result;
4027 PyObject * obj0 = 0 ;
4028 char *kwnames[] = {
4029 (char *) "wFlags", NULL
4030 };
4031
4032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4033 {
4034 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4035 if (SWIG_arg_fail(1)) SWIG_fail;
4036 }
4037 {
4038 if (!wxPyCheckForApp()) SWIG_fail;
4039 PyThreadState* __tstate = wxPyBeginAllowThreads();
4040 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4041
4042 wxPyEndAllowThreads(__tstate);
4043 if (PyErr_Occurred()) SWIG_fail;
4044 }
4045 {
4046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4047 }
4048 return resultobj;
4049 fail:
4050 return NULL;
4051 }
4052
4053
4054 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4055 PyObject *resultobj;
4056 int arg1 ;
4057 PyObject * obj0 = 0 ;
4058 char *kwnames[] = {
4059 (char *) "secs", NULL
4060 };
4061
4062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4063 {
4064 arg1 = (int)(SWIG_As_int(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 {
4068 PyThreadState* __tstate = wxPyBeginAllowThreads();
4069 wxSleep(arg1);
4070
4071 wxPyEndAllowThreads(__tstate);
4072 if (PyErr_Occurred()) SWIG_fail;
4073 }
4074 Py_INCREF(Py_None); resultobj = Py_None;
4075 return resultobj;
4076 fail:
4077 return NULL;
4078 }
4079
4080
4081 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4082 PyObject *resultobj;
4083 unsigned long arg1 ;
4084 PyObject * obj0 = 0 ;
4085 char *kwnames[] = {
4086 (char *) "milliseconds", NULL
4087 };
4088
4089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4090 {
4091 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4092 if (SWIG_arg_fail(1)) SWIG_fail;
4093 }
4094 {
4095 PyThreadState* __tstate = wxPyBeginAllowThreads();
4096 wxMilliSleep(arg1);
4097
4098 wxPyEndAllowThreads(__tstate);
4099 if (PyErr_Occurred()) SWIG_fail;
4100 }
4101 Py_INCREF(Py_None); resultobj = Py_None;
4102 return resultobj;
4103 fail:
4104 return NULL;
4105 }
4106
4107
4108 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj;
4110 unsigned long arg1 ;
4111 PyObject * obj0 = 0 ;
4112 char *kwnames[] = {
4113 (char *) "microseconds", NULL
4114 };
4115
4116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4117 {
4118 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4119 if (SWIG_arg_fail(1)) SWIG_fail;
4120 }
4121 {
4122 PyThreadState* __tstate = wxPyBeginAllowThreads();
4123 wxMicroSleep(arg1);
4124
4125 wxPyEndAllowThreads(__tstate);
4126 if (PyErr_Occurred()) SWIG_fail;
4127 }
4128 Py_INCREF(Py_None); resultobj = Py_None;
4129 return resultobj;
4130 fail:
4131 return NULL;
4132 }
4133
4134
4135 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4136 PyObject *resultobj;
4137 bool arg1 ;
4138 PyObject * obj0 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "enable", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4144 {
4145 arg1 = (bool)(SWIG_As_bool(obj0));
4146 if (SWIG_arg_fail(1)) SWIG_fail;
4147 }
4148 {
4149 PyThreadState* __tstate = wxPyBeginAllowThreads();
4150 wxEnableTopLevelWindows(arg1);
4151
4152 wxPyEndAllowThreads(__tstate);
4153 if (PyErr_Occurred()) SWIG_fail;
4154 }
4155 Py_INCREF(Py_None); resultobj = Py_None;
4156 return resultobj;
4157 fail:
4158 return NULL;
4159 }
4160
4161
4162 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4163 PyObject *resultobj;
4164 wxString *arg1 = 0 ;
4165 wxString result;
4166 bool temp1 = false ;
4167 PyObject * obj0 = 0 ;
4168 char *kwnames[] = {
4169 (char *) "in", NULL
4170 };
4171
4172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4173 {
4174 arg1 = wxString_in_helper(obj0);
4175 if (arg1 == NULL) SWIG_fail;
4176 temp1 = true;
4177 }
4178 {
4179 PyThreadState* __tstate = wxPyBeginAllowThreads();
4180 result = wxStripMenuCodes((wxString const &)*arg1);
4181
4182 wxPyEndAllowThreads(__tstate);
4183 if (PyErr_Occurred()) SWIG_fail;
4184 }
4185 {
4186 #if wxUSE_UNICODE
4187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4188 #else
4189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4190 #endif
4191 }
4192 {
4193 if (temp1)
4194 delete arg1;
4195 }
4196 return resultobj;
4197 fail:
4198 {
4199 if (temp1)
4200 delete arg1;
4201 }
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj;
4208 wxString result;
4209 char *kwnames[] = {
4210 NULL
4211 };
4212
4213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4214 {
4215 PyThreadState* __tstate = wxPyBeginAllowThreads();
4216 result = wxGetEmailAddress();
4217
4218 wxPyEndAllowThreads(__tstate);
4219 if (PyErr_Occurred()) SWIG_fail;
4220 }
4221 {
4222 #if wxUSE_UNICODE
4223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4224 #else
4225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4226 #endif
4227 }
4228 return resultobj;
4229 fail:
4230 return NULL;
4231 }
4232
4233
4234 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4235 PyObject *resultobj;
4236 wxString result;
4237 char *kwnames[] = {
4238 NULL
4239 };
4240
4241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 result = wxGetHostName();
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 {
4250 #if wxUSE_UNICODE
4251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4252 #else
4253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4254 #endif
4255 }
4256 return resultobj;
4257 fail:
4258 return NULL;
4259 }
4260
4261
4262 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4263 PyObject *resultobj;
4264 wxString result;
4265 char *kwnames[] = {
4266 NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4270 {
4271 PyThreadState* __tstate = wxPyBeginAllowThreads();
4272 result = wxGetFullHostName();
4273
4274 wxPyEndAllowThreads(__tstate);
4275 if (PyErr_Occurred()) SWIG_fail;
4276 }
4277 {
4278 #if wxUSE_UNICODE
4279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4280 #else
4281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4282 #endif
4283 }
4284 return resultobj;
4285 fail:
4286 return NULL;
4287 }
4288
4289
4290 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4291 PyObject *resultobj;
4292 wxString result;
4293 char *kwnames[] = {
4294 NULL
4295 };
4296
4297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4298 {
4299 PyThreadState* __tstate = wxPyBeginAllowThreads();
4300 result = wxGetUserId();
4301
4302 wxPyEndAllowThreads(__tstate);
4303 if (PyErr_Occurred()) SWIG_fail;
4304 }
4305 {
4306 #if wxUSE_UNICODE
4307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4308 #else
4309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4310 #endif
4311 }
4312 return resultobj;
4313 fail:
4314 return NULL;
4315 }
4316
4317
4318 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4319 PyObject *resultobj;
4320 wxString result;
4321 char *kwnames[] = {
4322 NULL
4323 };
4324
4325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4326 {
4327 PyThreadState* __tstate = wxPyBeginAllowThreads();
4328 result = wxGetUserName();
4329
4330 wxPyEndAllowThreads(__tstate);
4331 if (PyErr_Occurred()) SWIG_fail;
4332 }
4333 {
4334 #if wxUSE_UNICODE
4335 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4336 #else
4337 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4338 #endif
4339 }
4340 return resultobj;
4341 fail:
4342 return NULL;
4343 }
4344
4345
4346 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4347 PyObject *resultobj;
4348 wxString result;
4349 char *kwnames[] = {
4350 NULL
4351 };
4352
4353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4354 {
4355 PyThreadState* __tstate = wxPyBeginAllowThreads();
4356 result = wxGetHomeDir();
4357
4358 wxPyEndAllowThreads(__tstate);
4359 if (PyErr_Occurred()) SWIG_fail;
4360 }
4361 {
4362 #if wxUSE_UNICODE
4363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4364 #else
4365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4366 #endif
4367 }
4368 return resultobj;
4369 fail:
4370 return NULL;
4371 }
4372
4373
4374 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4375 PyObject *resultobj;
4376 wxString const &arg1_defvalue = wxPyEmptyString ;
4377 wxString *arg1 = (wxString *) &arg1_defvalue ;
4378 wxString result;
4379 bool temp1 = false ;
4380 PyObject * obj0 = 0 ;
4381 char *kwnames[] = {
4382 (char *) "user", NULL
4383 };
4384
4385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4386 if (obj0) {
4387 {
4388 arg1 = wxString_in_helper(obj0);
4389 if (arg1 == NULL) SWIG_fail;
4390 temp1 = true;
4391 }
4392 }
4393 {
4394 PyThreadState* __tstate = wxPyBeginAllowThreads();
4395 result = wxGetUserHome((wxString const &)*arg1);
4396
4397 wxPyEndAllowThreads(__tstate);
4398 if (PyErr_Occurred()) SWIG_fail;
4399 }
4400 {
4401 #if wxUSE_UNICODE
4402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4403 #else
4404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4405 #endif
4406 }
4407 {
4408 if (temp1)
4409 delete arg1;
4410 }
4411 return resultobj;
4412 fail:
4413 {
4414 if (temp1)
4415 delete arg1;
4416 }
4417 return NULL;
4418 }
4419
4420
4421 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4422 PyObject *resultobj;
4423 unsigned long result;
4424 char *kwnames[] = {
4425 NULL
4426 };
4427
4428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = (unsigned long)wxGetProcessId();
4432
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 {
4437 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4438 }
4439 return resultobj;
4440 fail:
4441 return NULL;
4442 }
4443
4444
4445 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4446 PyObject *resultobj;
4447 char *kwnames[] = {
4448 NULL
4449 };
4450
4451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4452 {
4453 PyThreadState* __tstate = wxPyBeginAllowThreads();
4454 wxTrap();
4455
4456 wxPyEndAllowThreads(__tstate);
4457 if (PyErr_Occurred()) SWIG_fail;
4458 }
4459 Py_INCREF(Py_None); resultobj = Py_None;
4460 return resultobj;
4461 fail:
4462 return NULL;
4463 }
4464
4465
4466 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj;
4468 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4469 wxString *arg1 = (wxString *) &arg1_defvalue ;
4470 wxString const &arg2_defvalue = wxPyEmptyString ;
4471 wxString *arg2 = (wxString *) &arg2_defvalue ;
4472 wxString const &arg3_defvalue = wxPyEmptyString ;
4473 wxString *arg3 = (wxString *) &arg3_defvalue ;
4474 wxString const &arg4_defvalue = wxPyEmptyString ;
4475 wxString *arg4 = (wxString *) &arg4_defvalue ;
4476 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4477 wxString *arg5 = (wxString *) &arg5_defvalue ;
4478 int arg6 = (int) 0 ;
4479 wxWindow *arg7 = (wxWindow *) NULL ;
4480 int arg8 = (int) -1 ;
4481 int arg9 = (int) -1 ;
4482 wxString result;
4483 bool temp1 = false ;
4484 bool temp2 = false ;
4485 bool temp3 = false ;
4486 bool temp4 = false ;
4487 bool temp5 = false ;
4488 PyObject * obj0 = 0 ;
4489 PyObject * obj1 = 0 ;
4490 PyObject * obj2 = 0 ;
4491 PyObject * obj3 = 0 ;
4492 PyObject * obj4 = 0 ;
4493 PyObject * obj5 = 0 ;
4494 PyObject * obj6 = 0 ;
4495 PyObject * obj7 = 0 ;
4496 PyObject * obj8 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4502 if (obj0) {
4503 {
4504 arg1 = wxString_in_helper(obj0);
4505 if (arg1 == NULL) SWIG_fail;
4506 temp1 = true;
4507 }
4508 }
4509 if (obj1) {
4510 {
4511 arg2 = wxString_in_helper(obj1);
4512 if (arg2 == NULL) SWIG_fail;
4513 temp2 = true;
4514 }
4515 }
4516 if (obj2) {
4517 {
4518 arg3 = wxString_in_helper(obj2);
4519 if (arg3 == NULL) SWIG_fail;
4520 temp3 = true;
4521 }
4522 }
4523 if (obj3) {
4524 {
4525 arg4 = wxString_in_helper(obj3);
4526 if (arg4 == NULL) SWIG_fail;
4527 temp4 = true;
4528 }
4529 }
4530 if (obj4) {
4531 {
4532 arg5 = wxString_in_helper(obj4);
4533 if (arg5 == NULL) SWIG_fail;
4534 temp5 = true;
4535 }
4536 }
4537 if (obj5) {
4538 {
4539 arg6 = (int)(SWIG_As_int(obj5));
4540 if (SWIG_arg_fail(6)) SWIG_fail;
4541 }
4542 }
4543 if (obj6) {
4544 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4545 if (SWIG_arg_fail(7)) SWIG_fail;
4546 }
4547 if (obj7) {
4548 {
4549 arg8 = (int)(SWIG_As_int(obj7));
4550 if (SWIG_arg_fail(8)) SWIG_fail;
4551 }
4552 }
4553 if (obj8) {
4554 {
4555 arg9 = (int)(SWIG_As_int(obj8));
4556 if (SWIG_arg_fail(9)) SWIG_fail;
4557 }
4558 }
4559 {
4560 if (!wxPyCheckForApp()) SWIG_fail;
4561 PyThreadState* __tstate = wxPyBeginAllowThreads();
4562 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4563
4564 wxPyEndAllowThreads(__tstate);
4565 if (PyErr_Occurred()) SWIG_fail;
4566 }
4567 {
4568 #if wxUSE_UNICODE
4569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4570 #else
4571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4572 #endif
4573 }
4574 {
4575 if (temp1)
4576 delete arg1;
4577 }
4578 {
4579 if (temp2)
4580 delete arg2;
4581 }
4582 {
4583 if (temp3)
4584 delete arg3;
4585 }
4586 {
4587 if (temp4)
4588 delete arg4;
4589 }
4590 {
4591 if (temp5)
4592 delete arg5;
4593 }
4594 return resultobj;
4595 fail:
4596 {
4597 if (temp1)
4598 delete arg1;
4599 }
4600 {
4601 if (temp2)
4602 delete arg2;
4603 }
4604 {
4605 if (temp3)
4606 delete arg3;
4607 }
4608 {
4609 if (temp4)
4610 delete arg4;
4611 }
4612 {
4613 if (temp5)
4614 delete arg5;
4615 }
4616 return NULL;
4617 }
4618
4619
4620 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4621 PyObject *resultobj;
4622 wxString *arg1 = 0 ;
4623 wxString *arg2 = 0 ;
4624 wxString const &arg3_defvalue = wxPyEmptyString ;
4625 wxString *arg3 = (wxString *) &arg3_defvalue ;
4626 wxWindow *arg4 = (wxWindow *) NULL ;
4627 wxString result;
4628 bool temp1 = false ;
4629 bool temp2 = false ;
4630 bool temp3 = false ;
4631 PyObject * obj0 = 0 ;
4632 PyObject * obj1 = 0 ;
4633 PyObject * obj2 = 0 ;
4634 PyObject * obj3 = 0 ;
4635 char *kwnames[] = {
4636 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4637 };
4638
4639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4640 {
4641 arg1 = wxString_in_helper(obj0);
4642 if (arg1 == NULL) SWIG_fail;
4643 temp1 = true;
4644 }
4645 {
4646 arg2 = wxString_in_helper(obj1);
4647 if (arg2 == NULL) SWIG_fail;
4648 temp2 = true;
4649 }
4650 if (obj2) {
4651 {
4652 arg3 = wxString_in_helper(obj2);
4653 if (arg3 == NULL) SWIG_fail;
4654 temp3 = true;
4655 }
4656 }
4657 if (obj3) {
4658 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4659 if (SWIG_arg_fail(4)) SWIG_fail;
4660 }
4661 {
4662 if (!wxPyCheckForApp()) SWIG_fail;
4663 PyThreadState* __tstate = wxPyBeginAllowThreads();
4664 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4665
4666 wxPyEndAllowThreads(__tstate);
4667 if (PyErr_Occurred()) SWIG_fail;
4668 }
4669 {
4670 #if wxUSE_UNICODE
4671 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4672 #else
4673 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4674 #endif
4675 }
4676 {
4677 if (temp1)
4678 delete arg1;
4679 }
4680 {
4681 if (temp2)
4682 delete arg2;
4683 }
4684 {
4685 if (temp3)
4686 delete arg3;
4687 }
4688 return resultobj;
4689 fail:
4690 {
4691 if (temp1)
4692 delete arg1;
4693 }
4694 {
4695 if (temp2)
4696 delete arg2;
4697 }
4698 {
4699 if (temp3)
4700 delete arg3;
4701 }
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj;
4708 wxString *arg1 = 0 ;
4709 wxString *arg2 = 0 ;
4710 wxString const &arg3_defvalue = wxPyEmptyString ;
4711 wxString *arg3 = (wxString *) &arg3_defvalue ;
4712 wxWindow *arg4 = (wxWindow *) NULL ;
4713 wxString result;
4714 bool temp1 = false ;
4715 bool temp2 = false ;
4716 bool temp3 = false ;
4717 PyObject * obj0 = 0 ;
4718 PyObject * obj1 = 0 ;
4719 PyObject * obj2 = 0 ;
4720 PyObject * obj3 = 0 ;
4721 char *kwnames[] = {
4722 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4723 };
4724
4725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4726 {
4727 arg1 = wxString_in_helper(obj0);
4728 if (arg1 == NULL) SWIG_fail;
4729 temp1 = true;
4730 }
4731 {
4732 arg2 = wxString_in_helper(obj1);
4733 if (arg2 == NULL) SWIG_fail;
4734 temp2 = true;
4735 }
4736 if (obj2) {
4737 {
4738 arg3 = wxString_in_helper(obj2);
4739 if (arg3 == NULL) SWIG_fail;
4740 temp3 = true;
4741 }
4742 }
4743 if (obj3) {
4744 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4745 if (SWIG_arg_fail(4)) SWIG_fail;
4746 }
4747 {
4748 if (!wxPyCheckForApp()) SWIG_fail;
4749 PyThreadState* __tstate = wxPyBeginAllowThreads();
4750 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4751
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 {
4756 #if wxUSE_UNICODE
4757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4758 #else
4759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4760 #endif
4761 }
4762 {
4763 if (temp1)
4764 delete arg1;
4765 }
4766 {
4767 if (temp2)
4768 delete arg2;
4769 }
4770 {
4771 if (temp3)
4772 delete arg3;
4773 }
4774 return resultobj;
4775 fail:
4776 {
4777 if (temp1)
4778 delete arg1;
4779 }
4780 {
4781 if (temp2)
4782 delete arg2;
4783 }
4784 {
4785 if (temp3)
4786 delete arg3;
4787 }
4788 return NULL;
4789 }
4790
4791
4792 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj;
4794 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4795 wxString *arg1 = (wxString *) &arg1_defvalue ;
4796 wxString const &arg2_defvalue = wxPyEmptyString ;
4797 wxString *arg2 = (wxString *) &arg2_defvalue ;
4798 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4799 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4800 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4801 wxWindow *arg5 = (wxWindow *) NULL ;
4802 wxString result;
4803 bool temp1 = false ;
4804 bool temp2 = false ;
4805 wxPoint temp4 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 PyObject * obj2 = 0 ;
4809 PyObject * obj3 = 0 ;
4810 PyObject * obj4 = 0 ;
4811 char *kwnames[] = {
4812 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4813 };
4814
4815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4816 if (obj0) {
4817 {
4818 arg1 = wxString_in_helper(obj0);
4819 if (arg1 == NULL) SWIG_fail;
4820 temp1 = true;
4821 }
4822 }
4823 if (obj1) {
4824 {
4825 arg2 = wxString_in_helper(obj1);
4826 if (arg2 == NULL) SWIG_fail;
4827 temp2 = true;
4828 }
4829 }
4830 if (obj2) {
4831 {
4832 arg3 = (long)(SWIG_As_long(obj2));
4833 if (SWIG_arg_fail(3)) SWIG_fail;
4834 }
4835 }
4836 if (obj3) {
4837 {
4838 arg4 = &temp4;
4839 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4840 }
4841 }
4842 if (obj4) {
4843 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4844 if (SWIG_arg_fail(5)) SWIG_fail;
4845 }
4846 {
4847 if (!wxPyCheckForApp()) SWIG_fail;
4848 PyThreadState* __tstate = wxPyBeginAllowThreads();
4849 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4850
4851 wxPyEndAllowThreads(__tstate);
4852 if (PyErr_Occurred()) SWIG_fail;
4853 }
4854 {
4855 #if wxUSE_UNICODE
4856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4857 #else
4858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4859 #endif
4860 }
4861 {
4862 if (temp1)
4863 delete arg1;
4864 }
4865 {
4866 if (temp2)
4867 delete arg2;
4868 }
4869 return resultobj;
4870 fail:
4871 {
4872 if (temp1)
4873 delete arg1;
4874 }
4875 {
4876 if (temp2)
4877 delete arg2;
4878 }
4879 return NULL;
4880 }
4881
4882
4883 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4884 PyObject *resultobj;
4885 wxString *arg1 = 0 ;
4886 wxString const &arg2_defvalue = wxPyEmptyString ;
4887 wxString *arg2 = (wxString *) &arg2_defvalue ;
4888 wxString const &arg3_defvalue = wxPyEmptyString ;
4889 wxString *arg3 = (wxString *) &arg3_defvalue ;
4890 wxWindow *arg4 = (wxWindow *) NULL ;
4891 int arg5 = (int) -1 ;
4892 int arg6 = (int) -1 ;
4893 bool arg7 = (bool) true ;
4894 wxString result;
4895 bool temp1 = false ;
4896 bool temp2 = false ;
4897 bool temp3 = false ;
4898 PyObject * obj0 = 0 ;
4899 PyObject * obj1 = 0 ;
4900 PyObject * obj2 = 0 ;
4901 PyObject * obj3 = 0 ;
4902 PyObject * obj4 = 0 ;
4903 PyObject * obj5 = 0 ;
4904 PyObject * obj6 = 0 ;
4905 char *kwnames[] = {
4906 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4907 };
4908
4909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4910 {
4911 arg1 = wxString_in_helper(obj0);
4912 if (arg1 == NULL) SWIG_fail;
4913 temp1 = true;
4914 }
4915 if (obj1) {
4916 {
4917 arg2 = wxString_in_helper(obj1);
4918 if (arg2 == NULL) SWIG_fail;
4919 temp2 = true;
4920 }
4921 }
4922 if (obj2) {
4923 {
4924 arg3 = wxString_in_helper(obj2);
4925 if (arg3 == NULL) SWIG_fail;
4926 temp3 = true;
4927 }
4928 }
4929 if (obj3) {
4930 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(4)) SWIG_fail;
4932 }
4933 if (obj4) {
4934 {
4935 arg5 = (int)(SWIG_As_int(obj4));
4936 if (SWIG_arg_fail(5)) SWIG_fail;
4937 }
4938 }
4939 if (obj5) {
4940 {
4941 arg6 = (int)(SWIG_As_int(obj5));
4942 if (SWIG_arg_fail(6)) SWIG_fail;
4943 }
4944 }
4945 if (obj6) {
4946 {
4947 arg7 = (bool)(SWIG_As_bool(obj6));
4948 if (SWIG_arg_fail(7)) SWIG_fail;
4949 }
4950 }
4951 {
4952 if (!wxPyCheckForApp()) SWIG_fail;
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4955
4956 wxPyEndAllowThreads(__tstate);
4957 if (PyErr_Occurred()) SWIG_fail;
4958 }
4959 {
4960 #if wxUSE_UNICODE
4961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4962 #else
4963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4964 #endif
4965 }
4966 {
4967 if (temp1)
4968 delete arg1;
4969 }
4970 {
4971 if (temp2)
4972 delete arg2;
4973 }
4974 {
4975 if (temp3)
4976 delete arg3;
4977 }
4978 return resultobj;
4979 fail:
4980 {
4981 if (temp1)
4982 delete arg1;
4983 }
4984 {
4985 if (temp2)
4986 delete arg2;
4987 }
4988 {
4989 if (temp3)
4990 delete arg3;
4991 }
4992 return NULL;
4993 }
4994
4995
4996 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4997 PyObject *resultobj;
4998 wxString *arg1 = 0 ;
4999 wxString const &arg2_defvalue = wxPyEmptyString ;
5000 wxString *arg2 = (wxString *) &arg2_defvalue ;
5001 wxString const &arg3_defvalue = wxPyEmptyString ;
5002 wxString *arg3 = (wxString *) &arg3_defvalue ;
5003 wxWindow *arg4 = (wxWindow *) NULL ;
5004 wxString result;
5005 bool temp1 = false ;
5006 bool temp2 = false ;
5007 bool temp3 = false ;
5008 PyObject * obj0 = 0 ;
5009 PyObject * obj1 = 0 ;
5010 PyObject * obj2 = 0 ;
5011 PyObject * obj3 = 0 ;
5012 char *kwnames[] = {
5013 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5014 };
5015
5016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5017 {
5018 arg1 = wxString_in_helper(obj0);
5019 if (arg1 == NULL) SWIG_fail;
5020 temp1 = true;
5021 }
5022 if (obj1) {
5023 {
5024 arg2 = wxString_in_helper(obj1);
5025 if (arg2 == NULL) SWIG_fail;
5026 temp2 = true;
5027 }
5028 }
5029 if (obj2) {
5030 {
5031 arg3 = wxString_in_helper(obj2);
5032 if (arg3 == NULL) SWIG_fail;
5033 temp3 = true;
5034 }
5035 }
5036 if (obj3) {
5037 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5038 if (SWIG_arg_fail(4)) SWIG_fail;
5039 }
5040 {
5041 if (!wxPyCheckForApp()) SWIG_fail;
5042 PyThreadState* __tstate = wxPyBeginAllowThreads();
5043 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5044
5045 wxPyEndAllowThreads(__tstate);
5046 if (PyErr_Occurred()) SWIG_fail;
5047 }
5048 {
5049 #if wxUSE_UNICODE
5050 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5051 #else
5052 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5053 #endif
5054 }
5055 {
5056 if (temp1)
5057 delete arg1;
5058 }
5059 {
5060 if (temp2)
5061 delete arg2;
5062 }
5063 {
5064 if (temp3)
5065 delete arg3;
5066 }
5067 return resultobj;
5068 fail:
5069 {
5070 if (temp1)
5071 delete arg1;
5072 }
5073 {
5074 if (temp2)
5075 delete arg2;
5076 }
5077 {
5078 if (temp3)
5079 delete arg3;
5080 }
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj;
5087 wxString *arg1 = 0 ;
5088 wxString *arg2 = 0 ;
5089 int arg3 ;
5090 wxString *arg4 = (wxString *) 0 ;
5091 wxWindow *arg5 = (wxWindow *) NULL ;
5092 int arg6 = (int) -1 ;
5093 int arg7 = (int) -1 ;
5094 bool arg8 = (bool) true ;
5095 int arg9 = (int) 150 ;
5096 int arg10 = (int) 200 ;
5097 wxString result;
5098 bool temp1 = false ;
5099 bool temp2 = false ;
5100 PyObject * obj0 = 0 ;
5101 PyObject * obj1 = 0 ;
5102 PyObject * obj2 = 0 ;
5103 PyObject * obj3 = 0 ;
5104 PyObject * obj4 = 0 ;
5105 PyObject * obj5 = 0 ;
5106 PyObject * obj6 = 0 ;
5107 PyObject * obj7 = 0 ;
5108 PyObject * obj8 = 0 ;
5109 char *kwnames[] = {
5110 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5111 };
5112
5113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5114 {
5115 arg1 = wxString_in_helper(obj0);
5116 if (arg1 == NULL) SWIG_fail;
5117 temp1 = true;
5118 }
5119 {
5120 arg2 = wxString_in_helper(obj1);
5121 if (arg2 == NULL) SWIG_fail;
5122 temp2 = true;
5123 }
5124 {
5125 arg3 = PyList_Size(obj2);
5126 arg4 = wxString_LIST_helper(obj2);
5127 if (arg4 == NULL) SWIG_fail;
5128 }
5129 if (obj3) {
5130 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5131 if (SWIG_arg_fail(5)) SWIG_fail;
5132 }
5133 if (obj4) {
5134 {
5135 arg6 = (int)(SWIG_As_int(obj4));
5136 if (SWIG_arg_fail(6)) SWIG_fail;
5137 }
5138 }
5139 if (obj5) {
5140 {
5141 arg7 = (int)(SWIG_As_int(obj5));
5142 if (SWIG_arg_fail(7)) SWIG_fail;
5143 }
5144 }
5145 if (obj6) {
5146 {
5147 arg8 = (bool)(SWIG_As_bool(obj6));
5148 if (SWIG_arg_fail(8)) SWIG_fail;
5149 }
5150 }
5151 if (obj7) {
5152 {
5153 arg9 = (int)(SWIG_As_int(obj7));
5154 if (SWIG_arg_fail(9)) SWIG_fail;
5155 }
5156 }
5157 if (obj8) {
5158 {
5159 arg10 = (int)(SWIG_As_int(obj8));
5160 if (SWIG_arg_fail(10)) SWIG_fail;
5161 }
5162 }
5163 {
5164 if (!wxPyCheckForApp()) SWIG_fail;
5165 PyThreadState* __tstate = wxPyBeginAllowThreads();
5166 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5167
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 #if wxUSE_UNICODE
5173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5174 #else
5175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5176 #endif
5177 }
5178 {
5179 if (temp1)
5180 delete arg1;
5181 }
5182 {
5183 if (temp2)
5184 delete arg2;
5185 }
5186 {
5187 if (arg4) delete [] arg4;
5188 }
5189 return resultobj;
5190 fail:
5191 {
5192 if (temp1)
5193 delete arg1;
5194 }
5195 {
5196 if (temp2)
5197 delete arg2;
5198 }
5199 {
5200 if (arg4) delete [] arg4;
5201 }
5202 return NULL;
5203 }
5204
5205
5206 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5207 PyObject *resultobj;
5208 wxString *arg1 = 0 ;
5209 wxString *arg2 = 0 ;
5210 int arg3 ;
5211 wxString *arg4 = (wxString *) 0 ;
5212 wxWindow *arg5 = (wxWindow *) NULL ;
5213 int arg6 = (int) -1 ;
5214 int arg7 = (int) -1 ;
5215 bool arg8 = (bool) true ;
5216 int arg9 = (int) 150 ;
5217 int arg10 = (int) 200 ;
5218 int result;
5219 bool temp1 = false ;
5220 bool temp2 = false ;
5221 PyObject * obj0 = 0 ;
5222 PyObject * obj1 = 0 ;
5223 PyObject * obj2 = 0 ;
5224 PyObject * obj3 = 0 ;
5225 PyObject * obj4 = 0 ;
5226 PyObject * obj5 = 0 ;
5227 PyObject * obj6 = 0 ;
5228 PyObject * obj7 = 0 ;
5229 PyObject * obj8 = 0 ;
5230 char *kwnames[] = {
5231 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5232 };
5233
5234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5235 {
5236 arg1 = wxString_in_helper(obj0);
5237 if (arg1 == NULL) SWIG_fail;
5238 temp1 = true;
5239 }
5240 {
5241 arg2 = wxString_in_helper(obj1);
5242 if (arg2 == NULL) SWIG_fail;
5243 temp2 = true;
5244 }
5245 {
5246 arg3 = PyList_Size(obj2);
5247 arg4 = wxString_LIST_helper(obj2);
5248 if (arg4 == NULL) SWIG_fail;
5249 }
5250 if (obj3) {
5251 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5252 if (SWIG_arg_fail(5)) SWIG_fail;
5253 }
5254 if (obj4) {
5255 {
5256 arg6 = (int)(SWIG_As_int(obj4));
5257 if (SWIG_arg_fail(6)) SWIG_fail;
5258 }
5259 }
5260 if (obj5) {
5261 {
5262 arg7 = (int)(SWIG_As_int(obj5));
5263 if (SWIG_arg_fail(7)) SWIG_fail;
5264 }
5265 }
5266 if (obj6) {
5267 {
5268 arg8 = (bool)(SWIG_As_bool(obj6));
5269 if (SWIG_arg_fail(8)) SWIG_fail;
5270 }
5271 }
5272 if (obj7) {
5273 {
5274 arg9 = (int)(SWIG_As_int(obj7));
5275 if (SWIG_arg_fail(9)) SWIG_fail;
5276 }
5277 }
5278 if (obj8) {
5279 {
5280 arg10 = (int)(SWIG_As_int(obj8));
5281 if (SWIG_arg_fail(10)) SWIG_fail;
5282 }
5283 }
5284 {
5285 if (!wxPyCheckForApp()) SWIG_fail;
5286 PyThreadState* __tstate = wxPyBeginAllowThreads();
5287 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5288
5289 wxPyEndAllowThreads(__tstate);
5290 if (PyErr_Occurred()) SWIG_fail;
5291 }
5292 {
5293 resultobj = SWIG_From_int((int)(result));
5294 }
5295 {
5296 if (temp1)
5297 delete arg1;
5298 }
5299 {
5300 if (temp2)
5301 delete arg2;
5302 }
5303 {
5304 if (arg4) delete [] arg4;
5305 }
5306 return resultobj;
5307 fail:
5308 {
5309 if (temp1)
5310 delete arg1;
5311 }
5312 {
5313 if (temp2)
5314 delete arg2;
5315 }
5316 {
5317 if (arg4) delete [] arg4;
5318 }
5319 return NULL;
5320 }
5321
5322
5323 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5324 PyObject *resultobj;
5325 wxString *arg1 = 0 ;
5326 wxString const &arg2_defvalue = wxPyEmptyString ;
5327 wxString *arg2 = (wxString *) &arg2_defvalue ;
5328 int arg3 = (int) wxOK|wxCENTRE ;
5329 wxWindow *arg4 = (wxWindow *) NULL ;
5330 int arg5 = (int) -1 ;
5331 int arg6 = (int) -1 ;
5332 int result;
5333 bool temp1 = false ;
5334 bool temp2 = false ;
5335 PyObject * obj0 = 0 ;
5336 PyObject * obj1 = 0 ;
5337 PyObject * obj2 = 0 ;
5338 PyObject * obj3 = 0 ;
5339 PyObject * obj4 = 0 ;
5340 PyObject * obj5 = 0 ;
5341 char *kwnames[] = {
5342 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5343 };
5344
5345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5346 {
5347 arg1 = wxString_in_helper(obj0);
5348 if (arg1 == NULL) SWIG_fail;
5349 temp1 = true;
5350 }
5351 if (obj1) {
5352 {
5353 arg2 = wxString_in_helper(obj1);
5354 if (arg2 == NULL) SWIG_fail;
5355 temp2 = true;
5356 }
5357 }
5358 if (obj2) {
5359 {
5360 arg3 = (int)(SWIG_As_int(obj2));
5361 if (SWIG_arg_fail(3)) SWIG_fail;
5362 }
5363 }
5364 if (obj3) {
5365 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5366 if (SWIG_arg_fail(4)) SWIG_fail;
5367 }
5368 if (obj4) {
5369 {
5370 arg5 = (int)(SWIG_As_int(obj4));
5371 if (SWIG_arg_fail(5)) SWIG_fail;
5372 }
5373 }
5374 if (obj5) {
5375 {
5376 arg6 = (int)(SWIG_As_int(obj5));
5377 if (SWIG_arg_fail(6)) SWIG_fail;
5378 }
5379 }
5380 {
5381 if (!wxPyCheckForApp()) SWIG_fail;
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5384
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 {
5389 resultobj = SWIG_From_int((int)(result));
5390 }
5391 {
5392 if (temp1)
5393 delete arg1;
5394 }
5395 {
5396 if (temp2)
5397 delete arg2;
5398 }
5399 return resultobj;
5400 fail:
5401 {
5402 if (temp1)
5403 delete arg1;
5404 }
5405 {
5406 if (temp2)
5407 delete arg2;
5408 }
5409 return NULL;
5410 }
5411
5412
5413 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5414 PyObject *resultobj;
5415 wxString *arg1 = 0 ;
5416 wxString *arg2 = 0 ;
5417 wxString *arg3 = 0 ;
5418 long arg4 ;
5419 long arg5 = (long) 0 ;
5420 long arg6 = (long) 100 ;
5421 wxWindow *arg7 = (wxWindow *) NULL ;
5422 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5423 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5424 long result;
5425 bool temp1 = false ;
5426 bool temp2 = false ;
5427 bool temp3 = false ;
5428 wxPoint temp8 ;
5429 PyObject * obj0 = 0 ;
5430 PyObject * obj1 = 0 ;
5431 PyObject * obj2 = 0 ;
5432 PyObject * obj3 = 0 ;
5433 PyObject * obj4 = 0 ;
5434 PyObject * obj5 = 0 ;
5435 PyObject * obj6 = 0 ;
5436 PyObject * obj7 = 0 ;
5437 char *kwnames[] = {
5438 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5439 };
5440
5441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5442 {
5443 arg1 = wxString_in_helper(obj0);
5444 if (arg1 == NULL) SWIG_fail;
5445 temp1 = true;
5446 }
5447 {
5448 arg2 = wxString_in_helper(obj1);
5449 if (arg2 == NULL) SWIG_fail;
5450 temp2 = true;
5451 }
5452 {
5453 arg3 = wxString_in_helper(obj2);
5454 if (arg3 == NULL) SWIG_fail;
5455 temp3 = true;
5456 }
5457 {
5458 arg4 = (long)(SWIG_As_long(obj3));
5459 if (SWIG_arg_fail(4)) SWIG_fail;
5460 }
5461 if (obj4) {
5462 {
5463 arg5 = (long)(SWIG_As_long(obj4));
5464 if (SWIG_arg_fail(5)) SWIG_fail;
5465 }
5466 }
5467 if (obj5) {
5468 {
5469 arg6 = (long)(SWIG_As_long(obj5));
5470 if (SWIG_arg_fail(6)) SWIG_fail;
5471 }
5472 }
5473 if (obj6) {
5474 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5475 if (SWIG_arg_fail(7)) SWIG_fail;
5476 }
5477 if (obj7) {
5478 {
5479 arg8 = &temp8;
5480 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5481 }
5482 }
5483 {
5484 if (!wxPyCheckForApp()) SWIG_fail;
5485 PyThreadState* __tstate = wxPyBeginAllowThreads();
5486 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5487
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 {
5492 resultobj = SWIG_From_long((long)(result));
5493 }
5494 {
5495 if (temp1)
5496 delete arg1;
5497 }
5498 {
5499 if (temp2)
5500 delete arg2;
5501 }
5502 {
5503 if (temp3)
5504 delete arg3;
5505 }
5506 return resultobj;
5507 fail:
5508 {
5509 if (temp1)
5510 delete arg1;
5511 }
5512 {
5513 if (temp2)
5514 delete arg2;
5515 }
5516 {
5517 if (temp3)
5518 delete arg3;
5519 }
5520 return NULL;
5521 }
5522
5523
5524 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj;
5526 bool result;
5527 char *kwnames[] = {
5528 NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5532 {
5533 if (!wxPyCheckForApp()) SWIG_fail;
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 result = (bool)wxColourDisplay();
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 {
5541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5542 }
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5550 PyObject *resultobj;
5551 int result;
5552 char *kwnames[] = {
5553 NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5557 {
5558 if (!wxPyCheckForApp()) SWIG_fail;
5559 PyThreadState* __tstate = wxPyBeginAllowThreads();
5560 result = (int)wxDisplayDepth();
5561
5562 wxPyEndAllowThreads(__tstate);
5563 if (PyErr_Occurred()) SWIG_fail;
5564 }
5565 {
5566 resultobj = SWIG_From_int((int)(result));
5567 }
5568 return resultobj;
5569 fail:
5570 return NULL;
5571 }
5572
5573
5574 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5575 PyObject *resultobj;
5576 int result;
5577 char *kwnames[] = {
5578 NULL
5579 };
5580
5581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5582 {
5583 if (!wxPyCheckForApp()) SWIG_fail;
5584 PyThreadState* __tstate = wxPyBeginAllowThreads();
5585 result = (int)wxGetDisplayDepth();
5586
5587 wxPyEndAllowThreads(__tstate);
5588 if (PyErr_Occurred()) SWIG_fail;
5589 }
5590 {
5591 resultobj = SWIG_From_int((int)(result));
5592 }
5593 return resultobj;
5594 fail:
5595 return NULL;
5596 }
5597
5598
5599 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5600 PyObject *resultobj;
5601 int *arg1 = (int *) 0 ;
5602 int *arg2 = (int *) 0 ;
5603 int temp1 ;
5604 int res1 = 0 ;
5605 int temp2 ;
5606 int res2 = 0 ;
5607 char *kwnames[] = {
5608 NULL
5609 };
5610
5611 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5612 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5614 {
5615 if (!wxPyCheckForApp()) SWIG_fail;
5616 PyThreadState* __tstate = wxPyBeginAllowThreads();
5617 wxDisplaySize(arg1,arg2);
5618
5619 wxPyEndAllowThreads(__tstate);
5620 if (PyErr_Occurred()) SWIG_fail;
5621 }
5622 Py_INCREF(Py_None); resultobj = Py_None;
5623 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5624 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5625 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5626 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj;
5635 wxSize result;
5636 char *kwnames[] = {
5637 NULL
5638 };
5639
5640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5641 {
5642 if (!wxPyCheckForApp()) SWIG_fail;
5643 PyThreadState* __tstate = wxPyBeginAllowThreads();
5644 result = wxGetDisplaySize();
5645
5646 wxPyEndAllowThreads(__tstate);
5647 if (PyErr_Occurred()) SWIG_fail;
5648 }
5649 {
5650 wxSize * resultptr;
5651 resultptr = new wxSize((wxSize &)(result));
5652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5653 }
5654 return resultobj;
5655 fail:
5656 return NULL;
5657 }
5658
5659
5660 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5661 PyObject *resultobj;
5662 int *arg1 = (int *) 0 ;
5663 int *arg2 = (int *) 0 ;
5664 int temp1 ;
5665 int res1 = 0 ;
5666 int temp2 ;
5667 int res2 = 0 ;
5668 char *kwnames[] = {
5669 NULL
5670 };
5671
5672 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5673 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5675 {
5676 if (!wxPyCheckForApp()) SWIG_fail;
5677 PyThreadState* __tstate = wxPyBeginAllowThreads();
5678 wxDisplaySizeMM(arg1,arg2);
5679
5680 wxPyEndAllowThreads(__tstate);
5681 if (PyErr_Occurred()) SWIG_fail;
5682 }
5683 Py_INCREF(Py_None); resultobj = Py_None;
5684 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5685 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5686 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5687 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj;
5696 wxSize result;
5697 char *kwnames[] = {
5698 NULL
5699 };
5700
5701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5702 {
5703 if (!wxPyCheckForApp()) SWIG_fail;
5704 PyThreadState* __tstate = wxPyBeginAllowThreads();
5705 result = wxGetDisplaySizeMM();
5706
5707 wxPyEndAllowThreads(__tstate);
5708 if (PyErr_Occurred()) SWIG_fail;
5709 }
5710 {
5711 wxSize * resultptr;
5712 resultptr = new wxSize((wxSize &)(result));
5713 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5714 }
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj;
5723 int *arg1 = (int *) 0 ;
5724 int *arg2 = (int *) 0 ;
5725 int *arg3 = (int *) 0 ;
5726 int *arg4 = (int *) 0 ;
5727 int temp1 ;
5728 int res1 = 0 ;
5729 int temp2 ;
5730 int res2 = 0 ;
5731 int temp3 ;
5732 int res3 = 0 ;
5733 int temp4 ;
5734 int res4 = 0 ;
5735 char *kwnames[] = {
5736 NULL
5737 };
5738
5739 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5740 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5741 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5742 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5744 {
5745 if (!wxPyCheckForApp()) SWIG_fail;
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 Py_INCREF(Py_None); resultobj = Py_None;
5753 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5754 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5755 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5756 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5757 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5758 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5759 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5760 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5761 return resultobj;
5762 fail:
5763 return NULL;
5764 }
5765
5766
5767 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5768 PyObject *resultobj;
5769 wxRect result;
5770 char *kwnames[] = {
5771 NULL
5772 };
5773
5774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5775 {
5776 if (!wxPyCheckForApp()) SWIG_fail;
5777 PyThreadState* __tstate = wxPyBeginAllowThreads();
5778 result = wxGetClientDisplayRect();
5779
5780 wxPyEndAllowThreads(__tstate);
5781 if (PyErr_Occurred()) SWIG_fail;
5782 }
5783 {
5784 wxRect * resultptr;
5785 resultptr = new wxRect((wxRect &)(result));
5786 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5787 }
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj;
5796 wxCursor *arg1 = 0 ;
5797 PyObject * obj0 = 0 ;
5798 char *kwnames[] = {
5799 (char *) "cursor", NULL
5800 };
5801
5802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5803 {
5804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5805 if (SWIG_arg_fail(1)) SWIG_fail;
5806 if (arg1 == NULL) {
5807 SWIG_null_ref("wxCursor");
5808 }
5809 if (SWIG_arg_fail(1)) SWIG_fail;
5810 }
5811 {
5812 if (!wxPyCheckForApp()) SWIG_fail;
5813 PyThreadState* __tstate = wxPyBeginAllowThreads();
5814 wxSetCursor(*arg1);
5815
5816 wxPyEndAllowThreads(__tstate);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 Py_INCREF(Py_None); resultobj = Py_None;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5827 PyObject *resultobj;
5828 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5829 PyObject * obj0 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "cursor", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5835 if (obj0) {
5836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5837 if (SWIG_arg_fail(1)) SWIG_fail;
5838 }
5839 {
5840 if (!wxPyCheckForApp()) SWIG_fail;
5841 PyThreadState* __tstate = wxPyBeginAllowThreads();
5842 wxBeginBusyCursor(arg1);
5843
5844 wxPyEndAllowThreads(__tstate);
5845 if (PyErr_Occurred()) SWIG_fail;
5846 }
5847 Py_INCREF(Py_None); resultobj = Py_None;
5848 return resultobj;
5849 fail:
5850 return NULL;
5851 }
5852
5853
5854 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5855 PyObject *resultobj;
5856 wxWindow *result;
5857 char *kwnames[] = {
5858 NULL
5859 };
5860
5861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5862 {
5863 if (!wxPyCheckForApp()) SWIG_fail;
5864 PyThreadState* __tstate = wxPyBeginAllowThreads();
5865 result = (wxWindow *)wxGetActiveWindow();
5866
5867 wxPyEndAllowThreads(__tstate);
5868 if (PyErr_Occurred()) SWIG_fail;
5869 }
5870 {
5871 resultobj = wxPyMake_wxObject(result, 0);
5872 }
5873 return resultobj;
5874 fail:
5875 return NULL;
5876 }
5877
5878
5879 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5880 PyObject *resultobj;
5881 wxPoint *arg1 = 0 ;
5882 wxWindow *result;
5883 wxPoint temp1 ;
5884 PyObject * obj0 = 0 ;
5885 char *kwnames[] = {
5886 (char *) "pt", NULL
5887 };
5888
5889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5890 {
5891 arg1 = &temp1;
5892 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5893 }
5894 {
5895 if (!wxPyCheckForApp()) SWIG_fail;
5896 PyThreadState* __tstate = wxPyBeginAllowThreads();
5897 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5898
5899 wxPyEndAllowThreads(__tstate);
5900 if (PyErr_Occurred()) SWIG_fail;
5901 }
5902 {
5903 resultobj = wxPyMake_wxObject(result, 0);
5904 }
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxPoint *arg1 = 0 ;
5914 wxWindow *result;
5915 wxPoint temp1 ;
5916 PyObject * obj0 = 0 ;
5917 char *kwnames[] = {
5918 (char *) "pt", NULL
5919 };
5920
5921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5922 {
5923 arg1 = &temp1;
5924 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5925 }
5926 {
5927 if (!wxPyCheckForApp()) SWIG_fail;
5928 PyThreadState* __tstate = wxPyBeginAllowThreads();
5929 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5930
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 {
5935 resultobj = wxPyMake_wxObject(result, 0);
5936 }
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj;
5945 wxWindow *arg1 = (wxWindow *) 0 ;
5946 wxWindow *result;
5947 PyObject * obj0 = 0 ;
5948 char *kwnames[] = {
5949 (char *) "win", NULL
5950 };
5951
5952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(1)) SWIG_fail;
5955 {
5956 if (!wxPyCheckForApp()) SWIG_fail;
5957 PyThreadState* __tstate = wxPyBeginAllowThreads();
5958 result = (wxWindow *)wxGetTopLevelParent(arg1);
5959
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 {
5964 resultobj = wxPyMake_wxObject(result, 0);
5965 }
5966 return resultobj;
5967 fail:
5968 return NULL;
5969 }
5970
5971
5972 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5973 PyObject *resultobj;
5974 wxKeyCode arg1 ;
5975 bool result;
5976 PyObject * obj0 = 0 ;
5977 char *kwnames[] = {
5978 (char *) "key", NULL
5979 };
5980
5981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5982 {
5983 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5984 if (SWIG_arg_fail(1)) SWIG_fail;
5985 }
5986 {
5987 if (!wxPyCheckForApp()) SWIG_fail;
5988 PyThreadState* __tstate = wxPyBeginAllowThreads();
5989 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5990
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 {
5995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5996 }
5997 return resultobj;
5998 fail:
5999 return NULL;
6000 }
6001
6002
6003 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
6004 PyObject *resultobj;
6005 char *kwnames[] = {
6006 NULL
6007 };
6008
6009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6010 {
6011 if (!wxPyCheckForApp()) SWIG_fail;
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 wxWakeUpMainThread();
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 Py_INCREF(Py_None); resultobj = Py_None;
6019 return resultobj;
6020 fail:
6021 return NULL;
6022 }
6023
6024
6025 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6026 PyObject *resultobj;
6027 char *kwnames[] = {
6028 NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6032 {
6033 if (!wxPyCheckForApp()) SWIG_fail;
6034 PyThreadState* __tstate = wxPyBeginAllowThreads();
6035 wxMutexGuiEnter();
6036
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 Py_INCREF(Py_None); resultobj = Py_None;
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6048 PyObject *resultobj;
6049 char *kwnames[] = {
6050 NULL
6051 };
6052
6053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6054 {
6055 if (!wxPyCheckForApp()) SWIG_fail;
6056 PyThreadState* __tstate = wxPyBeginAllowThreads();
6057 wxMutexGuiLeave();
6058
6059 wxPyEndAllowThreads(__tstate);
6060 if (PyErr_Occurred()) SWIG_fail;
6061 }
6062 Py_INCREF(Py_None); resultobj = Py_None;
6063 return resultobj;
6064 fail:
6065 return NULL;
6066 }
6067
6068
6069 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6070 PyObject *resultobj;
6071 wxMutexGuiLocker *result;
6072 char *kwnames[] = {
6073 NULL
6074 };
6075
6076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6077 {
6078 if (!wxPyCheckForApp()) SWIG_fail;
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6093 PyObject *resultobj;
6094 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6095 PyObject * obj0 = 0 ;
6096 char *kwnames[] = {
6097 (char *) "self", NULL
6098 };
6099
6100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6102 if (SWIG_arg_fail(1)) SWIG_fail;
6103 {
6104 PyThreadState* __tstate = wxPyBeginAllowThreads();
6105 delete arg1;
6106
6107 wxPyEndAllowThreads(__tstate);
6108 if (PyErr_Occurred()) SWIG_fail;
6109 }
6110 Py_INCREF(Py_None); resultobj = Py_None;
6111 return resultobj;
6112 fail:
6113 return NULL;
6114 }
6115
6116
6117 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6118 PyObject *obj;
6119 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6120 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6121 Py_INCREF(obj);
6122 return Py_BuildValue((char *)"");
6123 }
6124 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6125 PyObject *resultobj;
6126 bool result;
6127 char *kwnames[] = {
6128 NULL
6129 };
6130
6131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6132 {
6133 PyThreadState* __tstate = wxPyBeginAllowThreads();
6134 result = (bool)wxThread_IsMain();
6135
6136 wxPyEndAllowThreads(__tstate);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 {
6140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6141 }
6142 return resultobj;
6143 fail:
6144 return NULL;
6145 }
6146
6147
6148 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6149 PyObject *resultobj;
6150 wxString *arg1 = 0 ;
6151 wxToolTip *result;
6152 bool temp1 = false ;
6153 PyObject * obj0 = 0 ;
6154 char *kwnames[] = {
6155 (char *) "tip", NULL
6156 };
6157
6158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6159 {
6160 arg1 = wxString_in_helper(obj0);
6161 if (arg1 == NULL) SWIG_fail;
6162 temp1 = true;
6163 }
6164 {
6165 if (!wxPyCheckForApp()) SWIG_fail;
6166 PyThreadState* __tstate = wxPyBeginAllowThreads();
6167 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6168
6169 wxPyEndAllowThreads(__tstate);
6170 if (PyErr_Occurred()) SWIG_fail;
6171 }
6172 {
6173 resultobj = wxPyMake_wxObject(result, 1);
6174 }
6175 {
6176 if (temp1)
6177 delete arg1;
6178 }
6179 return resultobj;
6180 fail:
6181 {
6182 if (temp1)
6183 delete arg1;
6184 }
6185 return NULL;
6186 }
6187
6188
6189 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6190 PyObject *resultobj;
6191 wxToolTip *arg1 = (wxToolTip *) 0 ;
6192 wxString *arg2 = 0 ;
6193 bool temp2 = false ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char *kwnames[] = {
6197 (char *) "self",(char *) "tip", NULL
6198 };
6199
6200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6202 if (SWIG_arg_fail(1)) SWIG_fail;
6203 {
6204 arg2 = wxString_in_helper(obj1);
6205 if (arg2 == NULL) SWIG_fail;
6206 temp2 = true;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 (arg1)->SetTip((wxString const &)*arg2);
6211
6212 wxPyEndAllowThreads(__tstate);
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 Py_INCREF(Py_None); resultobj = Py_None;
6216 {
6217 if (temp2)
6218 delete arg2;
6219 }
6220 return resultobj;
6221 fail:
6222 {
6223 if (temp2)
6224 delete arg2;
6225 }
6226 return NULL;
6227 }
6228
6229
6230 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6231 PyObject *resultobj;
6232 wxToolTip *arg1 = (wxToolTip *) 0 ;
6233 wxString result;
6234 PyObject * obj0 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 PyThreadState* __tstate = wxPyBeginAllowThreads();
6244 result = (arg1)->GetTip();
6245
6246 wxPyEndAllowThreads(__tstate);
6247 if (PyErr_Occurred()) SWIG_fail;
6248 }
6249 {
6250 #if wxUSE_UNICODE
6251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6252 #else
6253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6254 #endif
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxToolTip *arg1 = (wxToolTip *) 0 ;
6265 wxWindow *result;
6266 PyObject * obj0 = 0 ;
6267 char *kwnames[] = {
6268 (char *) "self", NULL
6269 };
6270
6271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6273 if (SWIG_arg_fail(1)) SWIG_fail;
6274 {
6275 PyThreadState* __tstate = wxPyBeginAllowThreads();
6276 result = (wxWindow *)(arg1)->GetWindow();
6277
6278 wxPyEndAllowThreads(__tstate);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 {
6282 resultobj = wxPyMake_wxObject(result, 0);
6283 }
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj;
6292 bool arg1 ;
6293 PyObject * obj0 = 0 ;
6294 char *kwnames[] = {
6295 (char *) "flag", NULL
6296 };
6297
6298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6299 {
6300 arg1 = (bool)(SWIG_As_bool(obj0));
6301 if (SWIG_arg_fail(1)) SWIG_fail;
6302 }
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 wxToolTip::Enable(arg1);
6306
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 Py_INCREF(Py_None); resultobj = Py_None;
6311 return resultobj;
6312 fail:
6313 return NULL;
6314 }
6315
6316
6317 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6318 PyObject *resultobj;
6319 long arg1 ;
6320 PyObject * obj0 = 0 ;
6321 char *kwnames[] = {
6322 (char *) "milliseconds", NULL
6323 };
6324
6325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6326 {
6327 arg1 = (long)(SWIG_As_long(obj0));
6328 if (SWIG_arg_fail(1)) SWIG_fail;
6329 }
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 wxToolTip::SetDelay(arg1);
6333
6334 wxPyEndAllowThreads(__tstate);
6335 if (PyErr_Occurred()) SWIG_fail;
6336 }
6337 Py_INCREF(Py_None); resultobj = Py_None;
6338 return resultobj;
6339 fail:
6340 return NULL;
6341 }
6342
6343
6344 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6345 PyObject *obj;
6346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6347 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6348 Py_INCREF(obj);
6349 return Py_BuildValue((char *)"");
6350 }
6351 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6352 PyObject *resultobj;
6353 wxWindow *arg1 = (wxWindow *) 0 ;
6354 wxSize *arg2 = 0 ;
6355 wxCaret *result;
6356 wxSize temp2 ;
6357 PyObject * obj0 = 0 ;
6358 PyObject * obj1 = 0 ;
6359 char *kwnames[] = {
6360 (char *) "window",(char *) "size", NULL
6361 };
6362
6363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6365 if (SWIG_arg_fail(1)) SWIG_fail;
6366 {
6367 arg2 = &temp2;
6368 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6369 }
6370 {
6371 if (!wxPyCheckForApp()) SWIG_fail;
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6374
6375 wxPyEndAllowThreads(__tstate);
6376 if (PyErr_Occurred()) SWIG_fail;
6377 }
6378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6386 PyObject *resultobj;
6387 wxCaret *arg1 = (wxCaret *) 0 ;
6388 PyObject * obj0 = 0 ;
6389 char *kwnames[] = {
6390 (char *) "self", NULL
6391 };
6392
6393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6395 if (SWIG_arg_fail(1)) SWIG_fail;
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 wxCaret_Destroy(arg1);
6399
6400 wxPyEndAllowThreads(__tstate);
6401 if (PyErr_Occurred()) SWIG_fail;
6402 }
6403 Py_INCREF(Py_None); resultobj = Py_None;
6404 return resultobj;
6405 fail:
6406 return NULL;
6407 }
6408
6409
6410 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6411 PyObject *resultobj;
6412 wxCaret *arg1 = (wxCaret *) 0 ;
6413 bool result;
6414 PyObject * obj0 = 0 ;
6415 char *kwnames[] = {
6416 (char *) "self", NULL
6417 };
6418
6419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6421 if (SWIG_arg_fail(1)) SWIG_fail;
6422 {
6423 PyThreadState* __tstate = wxPyBeginAllowThreads();
6424 result = (bool)(arg1)->IsOk();
6425
6426 wxPyEndAllowThreads(__tstate);
6427 if (PyErr_Occurred()) SWIG_fail;
6428 }
6429 {
6430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6431 }
6432 return resultobj;
6433 fail:
6434 return NULL;
6435 }
6436
6437
6438 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6439 PyObject *resultobj;
6440 wxCaret *arg1 = (wxCaret *) 0 ;
6441 bool result;
6442 PyObject * obj0 = 0 ;
6443 char *kwnames[] = {
6444 (char *) "self", NULL
6445 };
6446
6447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6449 if (SWIG_arg_fail(1)) SWIG_fail;
6450 {
6451 PyThreadState* __tstate = wxPyBeginAllowThreads();
6452 result = (bool)(arg1)->IsVisible();
6453
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 {
6458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6459 }
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxCaret *arg1 = (wxCaret *) 0 ;
6469 wxPoint result;
6470 PyObject * obj0 = 0 ;
6471 char *kwnames[] = {
6472 (char *) "self", NULL
6473 };
6474
6475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6477 if (SWIG_arg_fail(1)) SWIG_fail;
6478 {
6479 PyThreadState* __tstate = wxPyBeginAllowThreads();
6480 result = (arg1)->GetPosition();
6481
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 {
6486 wxPoint * resultptr;
6487 resultptr = new wxPoint((wxPoint &)(result));
6488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6489 }
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6497 PyObject *resultobj;
6498 wxCaret *arg1 = (wxCaret *) 0 ;
6499 int *arg2 = (int *) 0 ;
6500 int *arg3 = (int *) 0 ;
6501 int temp2 ;
6502 int res2 = 0 ;
6503 int temp3 ;
6504 int res3 = 0 ;
6505 PyObject * obj0 = 0 ;
6506 char *kwnames[] = {
6507 (char *) "self", NULL
6508 };
6509
6510 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6511 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6514 if (SWIG_arg_fail(1)) SWIG_fail;
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 (arg1)->GetPosition(arg2,arg3);
6518
6519 wxPyEndAllowThreads(__tstate);
6520 if (PyErr_Occurred()) SWIG_fail;
6521 }
6522 Py_INCREF(Py_None); resultobj = Py_None;
6523 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6524 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6525 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6526 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6527 return resultobj;
6528 fail:
6529 return NULL;
6530 }
6531
6532
6533 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6534 PyObject *resultobj;
6535 wxCaret *arg1 = (wxCaret *) 0 ;
6536 wxSize result;
6537 PyObject * obj0 = 0 ;
6538 char *kwnames[] = {
6539 (char *) "self", NULL
6540 };
6541
6542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6544 if (SWIG_arg_fail(1)) SWIG_fail;
6545 {
6546 PyThreadState* __tstate = wxPyBeginAllowThreads();
6547 result = (arg1)->GetSize();
6548
6549 wxPyEndAllowThreads(__tstate);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 {
6553 wxSize * resultptr;
6554 resultptr = new wxSize((wxSize &)(result));
6555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6556 }
6557 return resultobj;
6558 fail:
6559 return NULL;
6560 }
6561
6562
6563 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6564 PyObject *resultobj;
6565 wxCaret *arg1 = (wxCaret *) 0 ;
6566 int *arg2 = (int *) 0 ;
6567 int *arg3 = (int *) 0 ;
6568 int temp2 ;
6569 int res2 = 0 ;
6570 int temp3 ;
6571 int res3 = 0 ;
6572 PyObject * obj0 = 0 ;
6573 char *kwnames[] = {
6574 (char *) "self", NULL
6575 };
6576
6577 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6578 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6581 if (SWIG_arg_fail(1)) SWIG_fail;
6582 {
6583 PyThreadState* __tstate = wxPyBeginAllowThreads();
6584 (arg1)->GetSize(arg2,arg3);
6585
6586 wxPyEndAllowThreads(__tstate);
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 Py_INCREF(Py_None); resultobj = Py_None;
6590 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6591 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6592 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6593 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj;
6602 wxCaret *arg1 = (wxCaret *) 0 ;
6603 wxWindow *result;
6604 PyObject * obj0 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self", NULL
6607 };
6608
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 result = (wxWindow *)(arg1)->GetWindow();
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 {
6620 resultobj = wxPyMake_wxObject(result, 0);
6621 }
6622 return resultobj;
6623 fail:
6624 return NULL;
6625 }
6626
6627
6628 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6629 PyObject *resultobj;
6630 wxCaret *arg1 = (wxCaret *) 0 ;
6631 int arg2 ;
6632 int arg3 ;
6633 PyObject * obj0 = 0 ;
6634 PyObject * obj1 = 0 ;
6635 PyObject * obj2 = 0 ;
6636 char *kwnames[] = {
6637 (char *) "self",(char *) "x",(char *) "y", NULL
6638 };
6639
6640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6642 if (SWIG_arg_fail(1)) SWIG_fail;
6643 {
6644 arg2 = (int)(SWIG_As_int(obj1));
6645 if (SWIG_arg_fail(2)) SWIG_fail;
6646 }
6647 {
6648 arg3 = (int)(SWIG_As_int(obj2));
6649 if (SWIG_arg_fail(3)) SWIG_fail;
6650 }
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 (arg1)->Move(arg2,arg3);
6654
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 Py_INCREF(Py_None); resultobj = Py_None;
6659 return resultobj;
6660 fail:
6661 return NULL;
6662 }
6663
6664
6665 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6666 PyObject *resultobj;
6667 wxCaret *arg1 = (wxCaret *) 0 ;
6668 wxPoint *arg2 = 0 ;
6669 wxPoint temp2 ;
6670 PyObject * obj0 = 0 ;
6671 PyObject * obj1 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self",(char *) "pt", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 arg2 = &temp2;
6681 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6682 }
6683 {
6684 PyThreadState* __tstate = wxPyBeginAllowThreads();
6685 (arg1)->Move((wxPoint const &)*arg2);
6686
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 Py_INCREF(Py_None); resultobj = Py_None;
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj;
6699 wxCaret *arg1 = (wxCaret *) 0 ;
6700 int arg2 ;
6701 int arg3 ;
6702 PyObject * obj0 = 0 ;
6703 PyObject * obj1 = 0 ;
6704 PyObject * obj2 = 0 ;
6705 char *kwnames[] = {
6706 (char *) "self",(char *) "width",(char *) "height", NULL
6707 };
6708
6709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6711 if (SWIG_arg_fail(1)) SWIG_fail;
6712 {
6713 arg2 = (int)(SWIG_As_int(obj1));
6714 if (SWIG_arg_fail(2)) SWIG_fail;
6715 }
6716 {
6717 arg3 = (int)(SWIG_As_int(obj2));
6718 if (SWIG_arg_fail(3)) SWIG_fail;
6719 }
6720 {
6721 PyThreadState* __tstate = wxPyBeginAllowThreads();
6722 (arg1)->SetSize(arg2,arg3);
6723
6724 wxPyEndAllowThreads(__tstate);
6725 if (PyErr_Occurred()) SWIG_fail;
6726 }
6727 Py_INCREF(Py_None); resultobj = Py_None;
6728 return resultobj;
6729 fail:
6730 return NULL;
6731 }
6732
6733
6734 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6735 PyObject *resultobj;
6736 wxCaret *arg1 = (wxCaret *) 0 ;
6737 wxSize *arg2 = 0 ;
6738 wxSize temp2 ;
6739 PyObject * obj0 = 0 ;
6740 PyObject * obj1 = 0 ;
6741 char *kwnames[] = {
6742 (char *) "self",(char *) "size", NULL
6743 };
6744
6745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6747 if (SWIG_arg_fail(1)) SWIG_fail;
6748 {
6749 arg2 = &temp2;
6750 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetSize((wxSize const &)*arg2);
6755
6756 wxPyEndAllowThreads(__tstate);
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 Py_INCREF(Py_None); resultobj = Py_None;
6760 return resultobj;
6761 fail:
6762 return NULL;
6763 }
6764
6765
6766 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6767 PyObject *resultobj;
6768 wxCaret *arg1 = (wxCaret *) 0 ;
6769 int arg2 = (int) true ;
6770 PyObject * obj0 = 0 ;
6771 PyObject * obj1 = 0 ;
6772 char *kwnames[] = {
6773 (char *) "self",(char *) "show", NULL
6774 };
6775
6776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6778 if (SWIG_arg_fail(1)) SWIG_fail;
6779 if (obj1) {
6780 {
6781 arg2 = (int)(SWIG_As_int(obj1));
6782 if (SWIG_arg_fail(2)) SWIG_fail;
6783 }
6784 }
6785 {
6786 PyThreadState* __tstate = wxPyBeginAllowThreads();
6787 (arg1)->Show(arg2);
6788
6789 wxPyEndAllowThreads(__tstate);
6790 if (PyErr_Occurred()) SWIG_fail;
6791 }
6792 Py_INCREF(Py_None); resultobj = Py_None;
6793 return resultobj;
6794 fail:
6795 return NULL;
6796 }
6797
6798
6799 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6800 PyObject *resultobj;
6801 wxCaret *arg1 = (wxCaret *) 0 ;
6802 PyObject * obj0 = 0 ;
6803 char *kwnames[] = {
6804 (char *) "self", NULL
6805 };
6806
6807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6809 if (SWIG_arg_fail(1)) SWIG_fail;
6810 {
6811 PyThreadState* __tstate = wxPyBeginAllowThreads();
6812 (arg1)->Hide();
6813
6814 wxPyEndAllowThreads(__tstate);
6815 if (PyErr_Occurred()) SWIG_fail;
6816 }
6817 Py_INCREF(Py_None); resultobj = Py_None;
6818 return resultobj;
6819 fail:
6820 return NULL;
6821 }
6822
6823
6824 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6825 PyObject *resultobj;
6826 int result;
6827 char *kwnames[] = {
6828 NULL
6829 };
6830
6831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6832 {
6833 PyThreadState* __tstate = wxPyBeginAllowThreads();
6834 result = (int)wxCaret::GetBlinkTime();
6835
6836 wxPyEndAllowThreads(__tstate);
6837 if (PyErr_Occurred()) SWIG_fail;
6838 }
6839 {
6840 resultobj = SWIG_From_int((int)(result));
6841 }
6842 return resultobj;
6843 fail:
6844 return NULL;
6845 }
6846
6847
6848 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6849 PyObject *resultobj;
6850 int arg1 ;
6851 PyObject * obj0 = 0 ;
6852 char *kwnames[] = {
6853 (char *) "milliseconds", NULL
6854 };
6855
6856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6857 {
6858 arg1 = (int)(SWIG_As_int(obj0));
6859 if (SWIG_arg_fail(1)) SWIG_fail;
6860 }
6861 {
6862 PyThreadState* __tstate = wxPyBeginAllowThreads();
6863 wxCaret::SetBlinkTime(arg1);
6864
6865 wxPyEndAllowThreads(__tstate);
6866 if (PyErr_Occurred()) SWIG_fail;
6867 }
6868 Py_INCREF(Py_None); resultobj = Py_None;
6869 return resultobj;
6870 fail:
6871 return NULL;
6872 }
6873
6874
6875 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6876 PyObject *obj;
6877 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6878 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6879 Py_INCREF(obj);
6880 return Py_BuildValue((char *)"");
6881 }
6882 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6883 PyObject *resultobj;
6884 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6885 wxBusyCursor *result;
6886 PyObject * obj0 = 0 ;
6887 char *kwnames[] = {
6888 (char *) "cursor", NULL
6889 };
6890
6891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6892 if (obj0) {
6893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6894 if (SWIG_arg_fail(1)) SWIG_fail;
6895 }
6896 {
6897 if (!wxPyCheckForApp()) SWIG_fail;
6898 PyThreadState* __tstate = wxPyBeginAllowThreads();
6899 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6900
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6912 PyObject *resultobj;
6913 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6914 PyObject * obj0 = 0 ;
6915 char *kwnames[] = {
6916 (char *) "self", NULL
6917 };
6918
6919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6921 if (SWIG_arg_fail(1)) SWIG_fail;
6922 {
6923 PyThreadState* __tstate = wxPyBeginAllowThreads();
6924 delete arg1;
6925
6926 wxPyEndAllowThreads(__tstate);
6927 if (PyErr_Occurred()) SWIG_fail;
6928 }
6929 Py_INCREF(Py_None); resultobj = Py_None;
6930 return resultobj;
6931 fail:
6932 return NULL;
6933 }
6934
6935
6936 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6937 PyObject *obj;
6938 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6939 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6940 Py_INCREF(obj);
6941 return Py_BuildValue((char *)"");
6942 }
6943 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj;
6945 wxWindow *arg1 = (wxWindow *) NULL ;
6946 wxWindowDisabler *result;
6947 PyObject * obj0 = 0 ;
6948 char *kwnames[] = {
6949 (char *) "winToSkip", NULL
6950 };
6951
6952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6953 if (obj0) {
6954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6955 if (SWIG_arg_fail(1)) SWIG_fail;
6956 }
6957 {
6958 if (!wxPyCheckForApp()) SWIG_fail;
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6961
6962 wxPyEndAllowThreads(__tstate);
6963 if (PyErr_Occurred()) SWIG_fail;
6964 }
6965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6966 return resultobj;
6967 fail:
6968 return NULL;
6969 }
6970
6971
6972 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6973 PyObject *resultobj;
6974 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6975 PyObject * obj0 = 0 ;
6976 char *kwnames[] = {
6977 (char *) "self", NULL
6978 };
6979
6980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6982 if (SWIG_arg_fail(1)) SWIG_fail;
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 delete arg1;
6986
6987 wxPyEndAllowThreads(__tstate);
6988 if (PyErr_Occurred()) SWIG_fail;
6989 }
6990 Py_INCREF(Py_None); resultobj = Py_None;
6991 return resultobj;
6992 fail:
6993 return NULL;
6994 }
6995
6996
6997 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6998 PyObject *obj;
6999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7000 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
7001 Py_INCREF(obj);
7002 return Py_BuildValue((char *)"");
7003 }
7004 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7005 PyObject *resultobj;
7006 wxString *arg1 = 0 ;
7007 wxBusyInfo *result;
7008 bool temp1 = false ;
7009 PyObject * obj0 = 0 ;
7010 char *kwnames[] = {
7011 (char *) "message", NULL
7012 };
7013
7014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7015 {
7016 arg1 = wxString_in_helper(obj0);
7017 if (arg1 == NULL) SWIG_fail;
7018 temp1 = true;
7019 }
7020 {
7021 if (!wxPyCheckForApp()) SWIG_fail;
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7024
7025 wxPyEndAllowThreads(__tstate);
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7029 {
7030 if (temp1)
7031 delete arg1;
7032 }
7033 return resultobj;
7034 fail:
7035 {
7036 if (temp1)
7037 delete arg1;
7038 }
7039 return NULL;
7040 }
7041
7042
7043 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7044 PyObject *resultobj;
7045 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7046 PyObject * obj0 = 0 ;
7047 char *kwnames[] = {
7048 (char *) "self", NULL
7049 };
7050
7051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7053 if (SWIG_arg_fail(1)) SWIG_fail;
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 delete arg1;
7057
7058 wxPyEndAllowThreads(__tstate);
7059 if (PyErr_Occurred()) SWIG_fail;
7060 }
7061 Py_INCREF(Py_None); resultobj = Py_None;
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7069 PyObject *obj;
7070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7071 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7072 Py_INCREF(obj);
7073 return Py_BuildValue((char *)"");
7074 }
7075 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7076 PyObject *resultobj;
7077 wxStopWatch *result;
7078 char *kwnames[] = {
7079 NULL
7080 };
7081
7082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7083 {
7084 PyThreadState* __tstate = wxPyBeginAllowThreads();
7085 result = (wxStopWatch *)new wxStopWatch();
7086
7087 wxPyEndAllowThreads(__tstate);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7098 PyObject *resultobj;
7099 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7100 long arg2 = (long) 0 ;
7101 PyObject * obj0 = 0 ;
7102 PyObject * obj1 = 0 ;
7103 char *kwnames[] = {
7104 (char *) "self",(char *) "t0", NULL
7105 };
7106
7107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7109 if (SWIG_arg_fail(1)) SWIG_fail;
7110 if (obj1) {
7111 {
7112 arg2 = (long)(SWIG_As_long(obj1));
7113 if (SWIG_arg_fail(2)) SWIG_fail;
7114 }
7115 }
7116 {
7117 PyThreadState* __tstate = wxPyBeginAllowThreads();
7118 (arg1)->Start(arg2);
7119
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 Py_INCREF(Py_None); resultobj = Py_None;
7124 return resultobj;
7125 fail:
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj;
7132 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7133 PyObject * obj0 = 0 ;
7134 char *kwnames[] = {
7135 (char *) "self", NULL
7136 };
7137
7138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7140 if (SWIG_arg_fail(1)) SWIG_fail;
7141 {
7142 PyThreadState* __tstate = wxPyBeginAllowThreads();
7143 (arg1)->Pause();
7144
7145 wxPyEndAllowThreads(__tstate);
7146 if (PyErr_Occurred()) SWIG_fail;
7147 }
7148 Py_INCREF(Py_None); resultobj = Py_None;
7149 return resultobj;
7150 fail:
7151 return NULL;
7152 }
7153
7154
7155 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7156 PyObject *resultobj;
7157 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7158 PyObject * obj0 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 (arg1)->Resume();
7169
7170 wxPyEndAllowThreads(__tstate);
7171 if (PyErr_Occurred()) SWIG_fail;
7172 }
7173 Py_INCREF(Py_None); resultobj = Py_None;
7174 return resultobj;
7175 fail:
7176 return NULL;
7177 }
7178
7179
7180 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7181 PyObject *resultobj;
7182 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7183 long result;
7184 PyObject * obj0 = 0 ;
7185 char *kwnames[] = {
7186 (char *) "self", NULL
7187 };
7188
7189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7191 if (SWIG_arg_fail(1)) SWIG_fail;
7192 {
7193 PyThreadState* __tstate = wxPyBeginAllowThreads();
7194 result = (long)((wxStopWatch const *)arg1)->Time();
7195
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 {
7200 resultobj = SWIG_From_long((long)(result));
7201 }
7202 return resultobj;
7203 fail:
7204 return NULL;
7205 }
7206
7207
7208 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7209 PyObject *obj;
7210 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7211 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7212 Py_INCREF(obj);
7213 return Py_BuildValue((char *)"");
7214 }
7215 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7216 PyObject *resultobj;
7217 int arg1 = (int) 9 ;
7218 int arg2 = (int) wxID_FILE1 ;
7219 wxFileHistory *result;
7220 PyObject * obj0 = 0 ;
7221 PyObject * obj1 = 0 ;
7222 char *kwnames[] = {
7223 (char *) "maxFiles",(char *) "idBase", NULL
7224 };
7225
7226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7227 if (obj0) {
7228 {
7229 arg1 = (int)(SWIG_As_int(obj0));
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 }
7232 }
7233 if (obj1) {
7234 {
7235 arg2 = (int)(SWIG_As_int(obj1));
7236 if (SWIG_arg_fail(2)) SWIG_fail;
7237 }
7238 }
7239 {
7240 PyThreadState* __tstate = wxPyBeginAllowThreads();
7241 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7242
7243 wxPyEndAllowThreads(__tstate);
7244 if (PyErr_Occurred()) SWIG_fail;
7245 }
7246 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7247 return resultobj;
7248 fail:
7249 return NULL;
7250 }
7251
7252
7253 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7254 PyObject *resultobj;
7255 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7256 PyObject * obj0 = 0 ;
7257 char *kwnames[] = {
7258 (char *) "self", NULL
7259 };
7260
7261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7263 if (SWIG_arg_fail(1)) SWIG_fail;
7264 {
7265 PyThreadState* __tstate = wxPyBeginAllowThreads();
7266 delete arg1;
7267
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 Py_INCREF(Py_None); resultobj = Py_None;
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj;
7280 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7281 wxString *arg2 = 0 ;
7282 bool temp2 = false ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "file", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 {
7293 arg2 = wxString_in_helper(obj1);
7294 if (arg2 == NULL) SWIG_fail;
7295 temp2 = true;
7296 }
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 (arg1)->AddFileToHistory((wxString const &)*arg2);
7300
7301 wxPyEndAllowThreads(__tstate);
7302 if (PyErr_Occurred()) SWIG_fail;
7303 }
7304 Py_INCREF(Py_None); resultobj = Py_None;
7305 {
7306 if (temp2)
7307 delete arg2;
7308 }
7309 return resultobj;
7310 fail:
7311 {
7312 if (temp2)
7313 delete arg2;
7314 }
7315 return NULL;
7316 }
7317
7318
7319 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7320 PyObject *resultobj;
7321 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7322 int arg2 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 char *kwnames[] = {
7326 (char *) "self",(char *) "i", NULL
7327 };
7328
7329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7331 if (SWIG_arg_fail(1)) SWIG_fail;
7332 {
7333 arg2 = (int)(SWIG_As_int(obj1));
7334 if (SWIG_arg_fail(2)) SWIG_fail;
7335 }
7336 {
7337 PyThreadState* __tstate = wxPyBeginAllowThreads();
7338 (arg1)->RemoveFileFromHistory(arg2);
7339
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 Py_INCREF(Py_None); resultobj = Py_None;
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj;
7352 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7353 int result;
7354 PyObject * obj0 = 0 ;
7355 char *kwnames[] = {
7356 (char *) "self", NULL
7357 };
7358
7359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7361 if (SWIG_arg_fail(1)) SWIG_fail;
7362 {
7363 PyThreadState* __tstate = wxPyBeginAllowThreads();
7364 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7365
7366 wxPyEndAllowThreads(__tstate);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 {
7370 resultobj = SWIG_From_int((int)(result));
7371 }
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7381 wxMenu *arg2 = (wxMenu *) 0 ;
7382 PyObject * obj0 = 0 ;
7383 PyObject * obj1 = 0 ;
7384 char *kwnames[] = {
7385 (char *) "self",(char *) "menu", NULL
7386 };
7387
7388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7390 if (SWIG_arg_fail(1)) SWIG_fail;
7391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(2)) SWIG_fail;
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 (arg1)->UseMenu(arg2);
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 Py_INCREF(Py_None); resultobj = Py_None;
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7410 wxMenu *arg2 = (wxMenu *) 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 char *kwnames[] = {
7414 (char *) "self",(char *) "menu", NULL
7415 };
7416
7417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7419 if (SWIG_arg_fail(1)) SWIG_fail;
7420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7421 if (SWIG_arg_fail(2)) SWIG_fail;
7422 {
7423 PyThreadState* __tstate = wxPyBeginAllowThreads();
7424 (arg1)->RemoveMenu(arg2);
7425
7426 wxPyEndAllowThreads(__tstate);
7427 if (PyErr_Occurred()) SWIG_fail;
7428 }
7429 Py_INCREF(Py_None); resultobj = Py_None;
7430 return resultobj;
7431 fail:
7432 return NULL;
7433 }
7434
7435
7436 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7437 PyObject *resultobj;
7438 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7439 wxConfigBase *arg2 = 0 ;
7440 PyObject * obj0 = 0 ;
7441 PyObject * obj1 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self",(char *) "config", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 {
7450 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7451 if (SWIG_arg_fail(2)) SWIG_fail;
7452 if (arg2 == NULL) {
7453 SWIG_null_ref("wxConfigBase");
7454 }
7455 if (SWIG_arg_fail(2)) SWIG_fail;
7456 }
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 (arg1)->Load(*arg2);
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 Py_INCREF(Py_None); resultobj = Py_None;
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7474 wxConfigBase *arg2 = 0 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 char *kwnames[] = {
7478 (char *) "self",(char *) "config", NULL
7479 };
7480
7481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7483 if (SWIG_arg_fail(1)) SWIG_fail;
7484 {
7485 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7486 if (SWIG_arg_fail(2)) SWIG_fail;
7487 if (arg2 == NULL) {
7488 SWIG_null_ref("wxConfigBase");
7489 }
7490 if (SWIG_arg_fail(2)) SWIG_fail;
7491 }
7492 {
7493 PyThreadState* __tstate = wxPyBeginAllowThreads();
7494 (arg1)->Save(*arg2);
7495
7496 wxPyEndAllowThreads(__tstate);
7497 if (PyErr_Occurred()) SWIG_fail;
7498 }
7499 Py_INCREF(Py_None); resultobj = Py_None;
7500 return resultobj;
7501 fail:
7502 return NULL;
7503 }
7504
7505
7506 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7507 PyObject *resultobj;
7508 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7509 PyObject * obj0 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 (arg1)->AddFilesToMenu();
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 Py_INCREF(Py_None); resultobj = Py_None;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7534 wxMenu *arg2 = (wxMenu *) 0 ;
7535 PyObject * obj0 = 0 ;
7536 PyObject * obj1 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self",(char *) "menu", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7545 if (SWIG_arg_fail(2)) SWIG_fail;
7546 {
7547 PyThreadState* __tstate = wxPyBeginAllowThreads();
7548 (arg1)->AddFilesToMenu(arg2);
7549
7550 wxPyEndAllowThreads(__tstate);
7551 if (PyErr_Occurred()) SWIG_fail;
7552 }
7553 Py_INCREF(Py_None); resultobj = Py_None;
7554 return resultobj;
7555 fail:
7556 return NULL;
7557 }
7558
7559
7560 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7561 PyObject *resultobj;
7562 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7563 int arg2 ;
7564 wxString result;
7565 PyObject * obj0 = 0 ;
7566 PyObject * obj1 = 0 ;
7567 char *kwnames[] = {
7568 (char *) "self",(char *) "i", NULL
7569 };
7570
7571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7573 if (SWIG_arg_fail(1)) SWIG_fail;
7574 {
7575 arg2 = (int)(SWIG_As_int(obj1));
7576 if (SWIG_arg_fail(2)) SWIG_fail;
7577 }
7578 {
7579 PyThreadState* __tstate = wxPyBeginAllowThreads();
7580 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7581
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 {
7586 #if wxUSE_UNICODE
7587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7588 #else
7589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7590 #endif
7591 }
7592 return resultobj;
7593 fail:
7594 return NULL;
7595 }
7596
7597
7598 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7599 PyObject *resultobj;
7600 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7601 int result;
7602 PyObject * obj0 = 0 ;
7603 char *kwnames[] = {
7604 (char *) "self", NULL
7605 };
7606
7607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7609 if (SWIG_arg_fail(1)) SWIG_fail;
7610 {
7611 PyThreadState* __tstate = wxPyBeginAllowThreads();
7612 result = (int)((wxFileHistory const *)arg1)->GetCount();
7613
7614 wxPyEndAllowThreads(__tstate);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 {
7618 resultobj = SWIG_From_int((int)(result));
7619 }
7620 return resultobj;
7621 fail:
7622 return NULL;
7623 }
7624
7625
7626 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7627 PyObject *obj;
7628 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7629 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7630 Py_INCREF(obj);
7631 return Py_BuildValue((char *)"");
7632 }
7633 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7634 PyObject *resultobj;
7635 wxString *arg1 = 0 ;
7636 wxString const &arg2_defvalue = wxPyEmptyString ;
7637 wxString *arg2 = (wxString *) &arg2_defvalue ;
7638 wxSingleInstanceChecker *result;
7639 bool temp1 = false ;
7640 bool temp2 = false ;
7641 PyObject * obj0 = 0 ;
7642 PyObject * obj1 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "name",(char *) "path", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7648 {
7649 arg1 = wxString_in_helper(obj0);
7650 if (arg1 == NULL) SWIG_fail;
7651 temp1 = true;
7652 }
7653 if (obj1) {
7654 {
7655 arg2 = wxString_in_helper(obj1);
7656 if (arg2 == NULL) SWIG_fail;
7657 temp2 = true;
7658 }
7659 }
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7668 {
7669 if (temp1)
7670 delete arg1;
7671 }
7672 {
7673 if (temp2)
7674 delete arg2;
7675 }
7676 return resultobj;
7677 fail:
7678 {
7679 if (temp1)
7680 delete arg1;
7681 }
7682 {
7683 if (temp2)
7684 delete arg2;
7685 }
7686 return NULL;
7687 }
7688
7689
7690 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj;
7692 wxSingleInstanceChecker *result;
7693 char *kwnames[] = {
7694 NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7698 {
7699 PyThreadState* __tstate = wxPyBeginAllowThreads();
7700 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7701
7702 wxPyEndAllowThreads(__tstate);
7703 if (PyErr_Occurred()) SWIG_fail;
7704 }
7705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7706 return resultobj;
7707 fail:
7708 return NULL;
7709 }
7710
7711
7712 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7713 PyObject *resultobj;
7714 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7715 PyObject * obj0 = 0 ;
7716 char *kwnames[] = {
7717 (char *) "self", NULL
7718 };
7719
7720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7722 if (SWIG_arg_fail(1)) SWIG_fail;
7723 {
7724 PyThreadState* __tstate = wxPyBeginAllowThreads();
7725 delete arg1;
7726
7727 wxPyEndAllowThreads(__tstate);
7728 if (PyErr_Occurred()) SWIG_fail;
7729 }
7730 Py_INCREF(Py_None); resultobj = Py_None;
7731 return resultobj;
7732 fail:
7733 return NULL;
7734 }
7735
7736
7737 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7738 PyObject *resultobj;
7739 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7740 wxString *arg2 = 0 ;
7741 wxString const &arg3_defvalue = wxPyEmptyString ;
7742 wxString *arg3 = (wxString *) &arg3_defvalue ;
7743 bool result;
7744 bool temp2 = false ;
7745 bool temp3 = false ;
7746 PyObject * obj0 = 0 ;
7747 PyObject * obj1 = 0 ;
7748 PyObject * obj2 = 0 ;
7749 char *kwnames[] = {
7750 (char *) "self",(char *) "name",(char *) "path", NULL
7751 };
7752
7753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7755 if (SWIG_arg_fail(1)) SWIG_fail;
7756 {
7757 arg2 = wxString_in_helper(obj1);
7758 if (arg2 == NULL) SWIG_fail;
7759 temp2 = true;
7760 }
7761 if (obj2) {
7762 {
7763 arg3 = wxString_in_helper(obj2);
7764 if (arg3 == NULL) SWIG_fail;
7765 temp3 = true;
7766 }
7767 }
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7771
7772 wxPyEndAllowThreads(__tstate);
7773 if (PyErr_Occurred()) SWIG_fail;
7774 }
7775 {
7776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7777 }
7778 {
7779 if (temp2)
7780 delete arg2;
7781 }
7782 {
7783 if (temp3)
7784 delete arg3;
7785 }
7786 return resultobj;
7787 fail:
7788 {
7789 if (temp2)
7790 delete arg2;
7791 }
7792 {
7793 if (temp3)
7794 delete arg3;
7795 }
7796 return NULL;
7797 }
7798
7799
7800 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj;
7802 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7803 bool result;
7804 PyObject * obj0 = 0 ;
7805 char *kwnames[] = {
7806 (char *) "self", NULL
7807 };
7808
7809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7811 if (SWIG_arg_fail(1)) SWIG_fail;
7812 {
7813 PyThreadState* __tstate = wxPyBeginAllowThreads();
7814 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7815
7816 wxPyEndAllowThreads(__tstate);
7817 if (PyErr_Occurred()) SWIG_fail;
7818 }
7819 {
7820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7821 }
7822 return resultobj;
7823 fail:
7824 return NULL;
7825 }
7826
7827
7828 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7829 PyObject *obj;
7830 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7831 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7832 Py_INCREF(obj);
7833 return Py_BuildValue((char *)"");
7834 }
7835 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj;
7837 wxWindow *arg1 = (wxWindow *) 0 ;
7838 wxDC *arg2 = 0 ;
7839 bool result;
7840 PyObject * obj0 = 0 ;
7841 PyObject * obj1 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "window",(char *) "dc", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7851 if (SWIG_arg_fail(2)) SWIG_fail;
7852 if (arg2 == NULL) {
7853 SWIG_null_ref("wxDC");
7854 }
7855 if (SWIG_arg_fail(2)) SWIG_fail;
7856 }
7857 {
7858 PyThreadState* __tstate = wxPyBeginAllowThreads();
7859 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7860
7861 wxPyEndAllowThreads(__tstate);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7866 }
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj;
7875 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7876 PyObject * obj0 = 0 ;
7877 char *kwnames[] = {
7878 (char *) "self", NULL
7879 };
7880
7881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7883 if (SWIG_arg_fail(1)) SWIG_fail;
7884 {
7885 PyThreadState* __tstate = wxPyBeginAllowThreads();
7886 delete arg1;
7887
7888 wxPyEndAllowThreads(__tstate);
7889 if (PyErr_Occurred()) SWIG_fail;
7890 }
7891 Py_INCREF(Py_None); resultobj = Py_None;
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7899 PyObject *resultobj;
7900 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7901 wxString result;
7902 PyObject * obj0 = 0 ;
7903 char *kwnames[] = {
7904 (char *) "self", NULL
7905 };
7906
7907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7909 if (SWIG_arg_fail(1)) SWIG_fail;
7910 {
7911 PyThreadState* __tstate = wxPyBeginAllowThreads();
7912 result = (arg1)->GetTip();
7913
7914 wxPyEndAllowThreads(__tstate);
7915 if (PyErr_Occurred()) SWIG_fail;
7916 }
7917 {
7918 #if wxUSE_UNICODE
7919 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7920 #else
7921 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7922 #endif
7923 }
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7931 PyObject *resultobj;
7932 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7933 size_t result;
7934 PyObject * obj0 = 0 ;
7935 char *kwnames[] = {
7936 (char *) "self", NULL
7937 };
7938
7939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7941 if (SWIG_arg_fail(1)) SWIG_fail;
7942 {
7943 PyThreadState* __tstate = wxPyBeginAllowThreads();
7944 result = (size_t)(arg1)->GetCurrentTip();
7945
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 {
7950 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7951 }
7952 return resultobj;
7953 fail:
7954 return NULL;
7955 }
7956
7957
7958 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7959 PyObject *resultobj;
7960 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7961 wxString *arg2 = 0 ;
7962 wxString result;
7963 bool temp2 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 char *kwnames[] = {
7967 (char *) "self",(char *) "tip", NULL
7968 };
7969
7970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7972 if (SWIG_arg_fail(1)) SWIG_fail;
7973 {
7974 arg2 = wxString_in_helper(obj1);
7975 if (arg2 == NULL) SWIG_fail;
7976 temp2 = true;
7977 }
7978 {
7979 PyThreadState* __tstate = wxPyBeginAllowThreads();
7980 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7981
7982 wxPyEndAllowThreads(__tstate);
7983 if (PyErr_Occurred()) SWIG_fail;
7984 }
7985 {
7986 #if wxUSE_UNICODE
7987 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7988 #else
7989 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7990 #endif
7991 }
7992 {
7993 if (temp2)
7994 delete arg2;
7995 }
7996 return resultobj;
7997 fail:
7998 {
7999 if (temp2)
8000 delete arg2;
8001 }
8002 return NULL;
8003 }
8004
8005
8006 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
8007 PyObject *obj;
8008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8009 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8010 Py_INCREF(obj);
8011 return Py_BuildValue((char *)"");
8012 }
8013 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8014 PyObject *resultobj;
8015 size_t arg1 ;
8016 wxPyTipProvider *result;
8017 PyObject * obj0 = 0 ;
8018 char *kwnames[] = {
8019 (char *) "currentTip", NULL
8020 };
8021
8022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8023 {
8024 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8025 if (SWIG_arg_fail(1)) SWIG_fail;
8026 }
8027 {
8028 PyThreadState* __tstate = wxPyBeginAllowThreads();
8029 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8030
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8035 return resultobj;
8036 fail:
8037 return NULL;
8038 }
8039
8040
8041 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8042 PyObject *resultobj;
8043 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8044 PyObject *arg2 = (PyObject *) 0 ;
8045 PyObject *arg3 = (PyObject *) 0 ;
8046 PyObject * obj0 = 0 ;
8047 PyObject * obj1 = 0 ;
8048 PyObject * obj2 = 0 ;
8049 char *kwnames[] = {
8050 (char *) "self",(char *) "self",(char *) "_class", NULL
8051 };
8052
8053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8055 if (SWIG_arg_fail(1)) SWIG_fail;
8056 arg2 = obj1;
8057 arg3 = obj2;
8058 {
8059 PyThreadState* __tstate = wxPyBeginAllowThreads();
8060 (arg1)->_setCallbackInfo(arg2,arg3);
8061
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 Py_INCREF(Py_None); resultobj = Py_None;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8073 PyObject *obj;
8074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8075 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8076 Py_INCREF(obj);
8077 return Py_BuildValue((char *)"");
8078 }
8079 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8080 PyObject *resultobj;
8081 wxWindow *arg1 = (wxWindow *) 0 ;
8082 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8083 bool arg3 = (bool) true ;
8084 bool result;
8085 PyObject * obj0 = 0 ;
8086 PyObject * obj1 = 0 ;
8087 PyObject * obj2 = 0 ;
8088 char *kwnames[] = {
8089 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8090 };
8091
8092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8094 if (SWIG_arg_fail(1)) SWIG_fail;
8095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8096 if (SWIG_arg_fail(2)) SWIG_fail;
8097 if (obj2) {
8098 {
8099 arg3 = (bool)(SWIG_As_bool(obj2));
8100 if (SWIG_arg_fail(3)) SWIG_fail;
8101 }
8102 }
8103 {
8104 if (!wxPyCheckForApp()) SWIG_fail;
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (bool)wxShowTip(arg1,arg2,arg3);
8107
8108 wxPyEndAllowThreads(__tstate);
8109 if (PyErr_Occurred()) SWIG_fail;
8110 }
8111 {
8112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8113 }
8114 return resultobj;
8115 fail:
8116 return NULL;
8117 }
8118
8119
8120 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8121 PyObject *resultobj;
8122 wxString *arg1 = 0 ;
8123 size_t arg2 ;
8124 wxTipProvider *result;
8125 bool temp1 = false ;
8126 PyObject * obj0 = 0 ;
8127 PyObject * obj1 = 0 ;
8128 char *kwnames[] = {
8129 (char *) "filename",(char *) "currentTip", NULL
8130 };
8131
8132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8133 {
8134 arg1 = wxString_in_helper(obj0);
8135 if (arg1 == NULL) SWIG_fail;
8136 temp1 = true;
8137 }
8138 {
8139 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8140 if (SWIG_arg_fail(2)) SWIG_fail;
8141 }
8142 {
8143 if (!wxPyCheckForApp()) SWIG_fail;
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8151 {
8152 if (temp1)
8153 delete arg1;
8154 }
8155 return resultobj;
8156 fail:
8157 {
8158 if (temp1)
8159 delete arg1;
8160 }
8161 return NULL;
8162 }
8163
8164
8165 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj;
8167 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8168 int arg2 = (int) -1 ;
8169 wxPyTimer *result;
8170 PyObject * obj0 = 0 ;
8171 PyObject * obj1 = 0 ;
8172 char *kwnames[] = {
8173 (char *) "owner",(char *) "id", NULL
8174 };
8175
8176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8177 if (obj0) {
8178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8179 if (SWIG_arg_fail(1)) SWIG_fail;
8180 }
8181 if (obj1) {
8182 {
8183 arg2 = (int)(SWIG_As_int(obj1));
8184 if (SWIG_arg_fail(2)) SWIG_fail;
8185 }
8186 }
8187 {
8188 if (!wxPyCheckForApp()) SWIG_fail;
8189 PyThreadState* __tstate = wxPyBeginAllowThreads();
8190 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8191
8192 wxPyEndAllowThreads(__tstate);
8193 if (PyErr_Occurred()) SWIG_fail;
8194 }
8195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8196 return resultobj;
8197 fail:
8198 return NULL;
8199 }
8200
8201
8202 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8203 PyObject *resultobj;
8204 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8205 PyObject * obj0 = 0 ;
8206 char *kwnames[] = {
8207 (char *) "self", NULL
8208 };
8209
8210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8212 if (SWIG_arg_fail(1)) SWIG_fail;
8213 {
8214 PyThreadState* __tstate = wxPyBeginAllowThreads();
8215 delete arg1;
8216
8217 wxPyEndAllowThreads(__tstate);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 Py_INCREF(Py_None); resultobj = Py_None;
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8228 PyObject *resultobj;
8229 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8230 PyObject *arg2 = (PyObject *) 0 ;
8231 PyObject *arg3 = (PyObject *) 0 ;
8232 int arg4 = (int) 1 ;
8233 PyObject * obj0 = 0 ;
8234 PyObject * obj1 = 0 ;
8235 PyObject * obj2 = 0 ;
8236 PyObject * obj3 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 arg2 = obj1;
8245 arg3 = obj2;
8246 if (obj3) {
8247 {
8248 arg4 = (int)(SWIG_As_int(obj3));
8249 if (SWIG_arg_fail(4)) SWIG_fail;
8250 }
8251 }
8252 {
8253 PyThreadState* __tstate = wxPyBeginAllowThreads();
8254 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8255
8256 wxPyEndAllowThreads(__tstate);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 Py_INCREF(Py_None); resultobj = Py_None;
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8267 PyObject *resultobj;
8268 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8269 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8270 int arg3 = (int) -1 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 PyObject * obj2 = 0 ;
8274 char *kwnames[] = {
8275 (char *) "self",(char *) "owner",(char *) "id", NULL
8276 };
8277
8278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8280 if (SWIG_arg_fail(1)) SWIG_fail;
8281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8282 if (SWIG_arg_fail(2)) SWIG_fail;
8283 if (obj2) {
8284 {
8285 arg3 = (int)(SWIG_As_int(obj2));
8286 if (SWIG_arg_fail(3)) SWIG_fail;
8287 }
8288 }
8289 {
8290 PyThreadState* __tstate = wxPyBeginAllowThreads();
8291 (arg1)->SetOwner(arg2,arg3);
8292
8293 wxPyEndAllowThreads(__tstate);
8294 if (PyErr_Occurred()) SWIG_fail;
8295 }
8296 Py_INCREF(Py_None); resultobj = Py_None;
8297 return resultobj;
8298 fail:
8299 return NULL;
8300 }
8301
8302
8303 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8304 PyObject *resultobj;
8305 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8306 wxEvtHandler *result;
8307 PyObject * obj0 = 0 ;
8308 char *kwnames[] = {
8309 (char *) "self", NULL
8310 };
8311
8312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8314 if (SWIG_arg_fail(1)) SWIG_fail;
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (wxEvtHandler *)(arg1)->GetOwner();
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = wxPyMake_wxObject(result, 0);
8324 }
8325 return resultobj;
8326 fail:
8327 return NULL;
8328 }
8329
8330
8331 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8332 PyObject *resultobj;
8333 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8334 int arg2 = (int) -1 ;
8335 bool arg3 = (bool) false ;
8336 bool result;
8337 PyObject * obj0 = 0 ;
8338 PyObject * obj1 = 0 ;
8339 PyObject * obj2 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 if (obj1) {
8348 {
8349 arg2 = (int)(SWIG_As_int(obj1));
8350 if (SWIG_arg_fail(2)) SWIG_fail;
8351 }
8352 }
8353 if (obj2) {
8354 {
8355 arg3 = (bool)(SWIG_As_bool(obj2));
8356 if (SWIG_arg_fail(3)) SWIG_fail;
8357 }
8358 }
8359 {
8360 PyThreadState* __tstate = wxPyBeginAllowThreads();
8361 result = (bool)(arg1)->Start(arg2,arg3);
8362
8363 wxPyEndAllowThreads(__tstate);
8364 if (PyErr_Occurred()) SWIG_fail;
8365 }
8366 {
8367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8368 }
8369 return resultobj;
8370 fail:
8371 return NULL;
8372 }
8373
8374
8375 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8376 PyObject *resultobj;
8377 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8378 PyObject * obj0 = 0 ;
8379 char *kwnames[] = {
8380 (char *) "self", NULL
8381 };
8382
8383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8385 if (SWIG_arg_fail(1)) SWIG_fail;
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 (arg1)->Stop();
8389
8390 wxPyEndAllowThreads(__tstate);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 Py_INCREF(Py_None); resultobj = Py_None;
8394 return resultobj;
8395 fail:
8396 return NULL;
8397 }
8398
8399
8400 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8401 PyObject *resultobj;
8402 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8403 bool result;
8404 PyObject * obj0 = 0 ;
8405 char *kwnames[] = {
8406 (char *) "self", NULL
8407 };
8408
8409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8411 if (SWIG_arg_fail(1)) SWIG_fail;
8412 {
8413 PyThreadState* __tstate = wxPyBeginAllowThreads();
8414 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8415
8416 wxPyEndAllowThreads(__tstate);
8417 if (PyErr_Occurred()) SWIG_fail;
8418 }
8419 {
8420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8421 }
8422 return resultobj;
8423 fail:
8424 return NULL;
8425 }
8426
8427
8428 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8429 PyObject *resultobj;
8430 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8431 int result;
8432 PyObject * obj0 = 0 ;
8433 char *kwnames[] = {
8434 (char *) "self", NULL
8435 };
8436
8437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8439 if (SWIG_arg_fail(1)) SWIG_fail;
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 {
8448 resultobj = SWIG_From_int((int)(result));
8449 }
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj;
8458 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8459 bool result;
8460 PyObject * obj0 = 0 ;
8461 char *kwnames[] = {
8462 (char *) "self", NULL
8463 };
8464
8465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8467 if (SWIG_arg_fail(1)) SWIG_fail;
8468 {
8469 PyThreadState* __tstate = wxPyBeginAllowThreads();
8470 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8471
8472 wxPyEndAllowThreads(__tstate);
8473 if (PyErr_Occurred()) SWIG_fail;
8474 }
8475 {
8476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8477 }
8478 return resultobj;
8479 fail:
8480 return NULL;
8481 }
8482
8483
8484 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8485 PyObject *resultobj;
8486 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8487 int result;
8488 PyObject * obj0 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 PyThreadState* __tstate = wxPyBeginAllowThreads();
8498 result = (int)((wxPyTimer const *)arg1)->GetId();
8499
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 {
8504 resultobj = SWIG_From_int((int)(result));
8505 }
8506 return resultobj;
8507 fail:
8508 return NULL;
8509 }
8510
8511
8512 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8513 PyObject *obj;
8514 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8515 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8516 Py_INCREF(obj);
8517 return Py_BuildValue((char *)"");
8518 }
8519 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8520 PyObject *resultobj;
8521 int arg1 = (int) 0 ;
8522 int arg2 = (int) 0 ;
8523 wxTimerEvent *result;
8524 PyObject * obj0 = 0 ;
8525 PyObject * obj1 = 0 ;
8526 char *kwnames[] = {
8527 (char *) "timerid",(char *) "interval", NULL
8528 };
8529
8530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8531 if (obj0) {
8532 {
8533 arg1 = (int)(SWIG_As_int(obj0));
8534 if (SWIG_arg_fail(1)) SWIG_fail;
8535 }
8536 }
8537 if (obj1) {
8538 {
8539 arg2 = (int)(SWIG_As_int(obj1));
8540 if (SWIG_arg_fail(2)) SWIG_fail;
8541 }
8542 }
8543 {
8544 PyThreadState* __tstate = wxPyBeginAllowThreads();
8545 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8546
8547 wxPyEndAllowThreads(__tstate);
8548 if (PyErr_Occurred()) SWIG_fail;
8549 }
8550 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8551 return resultobj;
8552 fail:
8553 return NULL;
8554 }
8555
8556
8557 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8558 PyObject *resultobj;
8559 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8560 int result;
8561 PyObject * obj0 = 0 ;
8562 char *kwnames[] = {
8563 (char *) "self", NULL
8564 };
8565
8566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8568 if (SWIG_arg_fail(1)) SWIG_fail;
8569 {
8570 PyThreadState* __tstate = wxPyBeginAllowThreads();
8571 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8572
8573 wxPyEndAllowThreads(__tstate);
8574 if (PyErr_Occurred()) SWIG_fail;
8575 }
8576 {
8577 resultobj = SWIG_From_int((int)(result));
8578 }
8579 return resultobj;
8580 fail:
8581 return NULL;
8582 }
8583
8584
8585 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8586 PyObject *obj;
8587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8588 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8589 Py_INCREF(obj);
8590 return Py_BuildValue((char *)"");
8591 }
8592 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8593 PyObject *resultobj;
8594 wxTimer *arg1 = 0 ;
8595 wxTimerRunner *result;
8596 PyObject * obj0 = 0 ;
8597
8598 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8599 {
8600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8601 if (SWIG_arg_fail(1)) SWIG_fail;
8602 if (arg1 == NULL) {
8603 SWIG_null_ref("wxTimer");
8604 }
8605 if (SWIG_arg_fail(1)) SWIG_fail;
8606 }
8607 {
8608 if (!wxPyCheckForApp()) SWIG_fail;
8609 PyThreadState* __tstate = wxPyBeginAllowThreads();
8610 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8611
8612 wxPyEndAllowThreads(__tstate);
8613 if (PyErr_Occurred()) SWIG_fail;
8614 }
8615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8616 return resultobj;
8617 fail:
8618 return NULL;
8619 }
8620
8621
8622 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8623 PyObject *resultobj;
8624 wxTimer *arg1 = 0 ;
8625 int arg2 ;
8626 bool arg3 = (bool) false ;
8627 wxTimerRunner *result;
8628 PyObject * obj0 = 0 ;
8629 PyObject * obj1 = 0 ;
8630 PyObject * obj2 = 0 ;
8631
8632 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8633 {
8634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8635 if (SWIG_arg_fail(1)) SWIG_fail;
8636 if (arg1 == NULL) {
8637 SWIG_null_ref("wxTimer");
8638 }
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 }
8641 {
8642 arg2 = (int)(SWIG_As_int(obj1));
8643 if (SWIG_arg_fail(2)) SWIG_fail;
8644 }
8645 if (obj2) {
8646 {
8647 arg3 = (bool)(SWIG_As_bool(obj2));
8648 if (SWIG_arg_fail(3)) SWIG_fail;
8649 }
8650 }
8651 {
8652 if (!wxPyCheckForApp()) SWIG_fail;
8653 PyThreadState* __tstate = wxPyBeginAllowThreads();
8654 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8655
8656 wxPyEndAllowThreads(__tstate);
8657 if (PyErr_Occurred()) SWIG_fail;
8658 }
8659 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8660 return resultobj;
8661 fail:
8662 return NULL;
8663 }
8664
8665
8666 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8667 int argc;
8668 PyObject *argv[4];
8669 int ii;
8670
8671 argc = PyObject_Length(args);
8672 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8673 argv[ii] = PyTuple_GetItem(args,ii);
8674 }
8675 if (argc == 1) {
8676 int _v;
8677 {
8678 void *ptr = 0;
8679 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8680 _v = 0;
8681 PyErr_Clear();
8682 } else {
8683 _v = (ptr != 0);
8684 }
8685 }
8686 if (_v) {
8687 return _wrap_new_TimerRunner__SWIG_0(self,args);
8688 }
8689 }
8690 if ((argc >= 2) && (argc <= 3)) {
8691 int _v;
8692 {
8693 void *ptr = 0;
8694 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8695 _v = 0;
8696 PyErr_Clear();
8697 } else {
8698 _v = (ptr != 0);
8699 }
8700 }
8701 if (_v) {
8702 _v = SWIG_Check_int(argv[1]);
8703 if (_v) {
8704 if (argc <= 2) {
8705 return _wrap_new_TimerRunner__SWIG_1(self,args);
8706 }
8707 _v = SWIG_Check_bool(argv[2]);
8708 if (_v) {
8709 return _wrap_new_TimerRunner__SWIG_1(self,args);
8710 }
8711 }
8712 }
8713 }
8714
8715 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8716 return NULL;
8717 }
8718
8719
8720 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj;
8722 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8723 PyObject * obj0 = 0 ;
8724 char *kwnames[] = {
8725 (char *) "self", NULL
8726 };
8727
8728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8730 if (SWIG_arg_fail(1)) SWIG_fail;
8731 {
8732 PyThreadState* __tstate = wxPyBeginAllowThreads();
8733 delete arg1;
8734
8735 wxPyEndAllowThreads(__tstate);
8736 if (PyErr_Occurred()) SWIG_fail;
8737 }
8738 Py_INCREF(Py_None); resultobj = Py_None;
8739 return resultobj;
8740 fail:
8741 return NULL;
8742 }
8743
8744
8745 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8746 PyObject *resultobj;
8747 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8748 int arg2 ;
8749 bool arg3 = (bool) false ;
8750 PyObject * obj0 = 0 ;
8751 PyObject * obj1 = 0 ;
8752 PyObject * obj2 = 0 ;
8753 char *kwnames[] = {
8754 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8755 };
8756
8757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8759 if (SWIG_arg_fail(1)) SWIG_fail;
8760 {
8761 arg2 = (int)(SWIG_As_int(obj1));
8762 if (SWIG_arg_fail(2)) SWIG_fail;
8763 }
8764 if (obj2) {
8765 {
8766 arg3 = (bool)(SWIG_As_bool(obj2));
8767 if (SWIG_arg_fail(3)) SWIG_fail;
8768 }
8769 }
8770 {
8771 PyThreadState* __tstate = wxPyBeginAllowThreads();
8772 (arg1)->Start(arg2,arg3);
8773
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 Py_INCREF(Py_None); resultobj = Py_None;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8785 PyObject *obj;
8786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8787 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8788 Py_INCREF(obj);
8789 return Py_BuildValue((char *)"");
8790 }
8791 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxLog *result;
8794 char *kwnames[] = {
8795 NULL
8796 };
8797
8798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8799 {
8800 PyThreadState* __tstate = wxPyBeginAllowThreads();
8801 result = (wxLog *)new wxLog();
8802
8803 wxPyEndAllowThreads(__tstate);
8804 if (PyErr_Occurred()) SWIG_fail;
8805 }
8806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8807 return resultobj;
8808 fail:
8809 return NULL;
8810 }
8811
8812
8813 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8814 PyObject *resultobj;
8815 bool result;
8816 char *kwnames[] = {
8817 NULL
8818 };
8819
8820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8821 {
8822 PyThreadState* __tstate = wxPyBeginAllowThreads();
8823 result = (bool)wxLog::IsEnabled();
8824
8825 wxPyEndAllowThreads(__tstate);
8826 if (PyErr_Occurred()) SWIG_fail;
8827 }
8828 {
8829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8830 }
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8838 PyObject *resultobj;
8839 bool arg1 = (bool) true ;
8840 bool result;
8841 PyObject * obj0 = 0 ;
8842 char *kwnames[] = {
8843 (char *) "doIt", NULL
8844 };
8845
8846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8847 if (obj0) {
8848 {
8849 arg1 = (bool)(SWIG_As_bool(obj0));
8850 if (SWIG_arg_fail(1)) SWIG_fail;
8851 }
8852 }
8853 {
8854 PyThreadState* __tstate = wxPyBeginAllowThreads();
8855 result = (bool)wxLog::EnableLogging(arg1);
8856
8857 wxPyEndAllowThreads(__tstate);
8858 if (PyErr_Occurred()) SWIG_fail;
8859 }
8860 {
8861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8862 }
8863 return resultobj;
8864 fail:
8865 return NULL;
8866 }
8867
8868
8869 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8870 PyObject *resultobj;
8871 wxLogLevel arg1 ;
8872 wxChar *arg2 = (wxChar *) 0 ;
8873 time_t arg3 ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 PyObject * obj2 = 0 ;
8877 char *kwnames[] = {
8878 (char *) "level",(char *) "szString",(char *) "t", NULL
8879 };
8880
8881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8882 {
8883 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8884 if (SWIG_arg_fail(1)) SWIG_fail;
8885 }
8886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8887 if (SWIG_arg_fail(2)) SWIG_fail;
8888 {
8889 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8890 if (SWIG_arg_fail(3)) SWIG_fail;
8891 }
8892 {
8893 PyThreadState* __tstate = wxPyBeginAllowThreads();
8894 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8895
8896 wxPyEndAllowThreads(__tstate);
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 Py_INCREF(Py_None); resultobj = Py_None;
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj;
8908 wxLog *arg1 = (wxLog *) 0 ;
8909 PyObject * obj0 = 0 ;
8910 char *kwnames[] = {
8911 (char *) "self", NULL
8912 };
8913
8914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8916 if (SWIG_arg_fail(1)) SWIG_fail;
8917 {
8918 PyThreadState* __tstate = wxPyBeginAllowThreads();
8919 (arg1)->Flush();
8920
8921 wxPyEndAllowThreads(__tstate);
8922 if (PyErr_Occurred()) SWIG_fail;
8923 }
8924 Py_INCREF(Py_None); resultobj = Py_None;
8925 return resultobj;
8926 fail:
8927 return NULL;
8928 }
8929
8930
8931 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8932 PyObject *resultobj;
8933 char *kwnames[] = {
8934 NULL
8935 };
8936
8937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8938 {
8939 PyThreadState* __tstate = wxPyBeginAllowThreads();
8940 wxLog::FlushActive();
8941
8942 wxPyEndAllowThreads(__tstate);
8943 if (PyErr_Occurred()) SWIG_fail;
8944 }
8945 Py_INCREF(Py_None); resultobj = Py_None;
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8953 PyObject *resultobj;
8954 wxLog *result;
8955 char *kwnames[] = {
8956 NULL
8957 };
8958
8959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8960 {
8961 PyThreadState* __tstate = wxPyBeginAllowThreads();
8962 result = (wxLog *)wxLog::GetActiveTarget();
8963
8964 wxPyEndAllowThreads(__tstate);
8965 if (PyErr_Occurred()) SWIG_fail;
8966 }
8967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8968 return resultobj;
8969 fail:
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxLog *arg1 = (wxLog *) 0 ;
8977 wxLog *result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "pLogger", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj;
9002 char *kwnames[] = {
9003 NULL
9004 };
9005
9006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
9007 {
9008 PyThreadState* __tstate = wxPyBeginAllowThreads();
9009 wxLog::Suspend();
9010
9011 wxPyEndAllowThreads(__tstate);
9012 if (PyErr_Occurred()) SWIG_fail;
9013 }
9014 Py_INCREF(Py_None); resultobj = Py_None;
9015 return resultobj;
9016 fail:
9017 return NULL;
9018 }
9019
9020
9021 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9022 PyObject *resultobj;
9023 char *kwnames[] = {
9024 NULL
9025 };
9026
9027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 wxLog::Resume();
9031
9032 wxPyEndAllowThreads(__tstate);
9033 if (PyErr_Occurred()) SWIG_fail;
9034 }
9035 Py_INCREF(Py_None); resultobj = Py_None;
9036 return resultobj;
9037 fail:
9038 return NULL;
9039 }
9040
9041
9042 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9043 PyObject *resultobj;
9044 bool arg1 = (bool) true ;
9045 PyObject * obj0 = 0 ;
9046 char *kwnames[] = {
9047 (char *) "bVerbose", NULL
9048 };
9049
9050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9051 if (obj0) {
9052 {
9053 arg1 = (bool)(SWIG_As_bool(obj0));
9054 if (SWIG_arg_fail(1)) SWIG_fail;
9055 }
9056 }
9057 {
9058 PyThreadState* __tstate = wxPyBeginAllowThreads();
9059 wxLog::SetVerbose(arg1);
9060
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 Py_INCREF(Py_None); resultobj = Py_None;
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9072 PyObject *resultobj;
9073 wxLogLevel arg1 ;
9074 PyObject * obj0 = 0 ;
9075 char *kwnames[] = {
9076 (char *) "logLevel", NULL
9077 };
9078
9079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9080 {
9081 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9082 if (SWIG_arg_fail(1)) SWIG_fail;
9083 }
9084 {
9085 PyThreadState* __tstate = wxPyBeginAllowThreads();
9086 wxLog::SetLogLevel(arg1);
9087
9088 wxPyEndAllowThreads(__tstate);
9089 if (PyErr_Occurred()) SWIG_fail;
9090 }
9091 Py_INCREF(Py_None); resultobj = Py_None;
9092 return resultobj;
9093 fail:
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 char *kwnames[] = {
9101 NULL
9102 };
9103
9104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9105 {
9106 PyThreadState* __tstate = wxPyBeginAllowThreads();
9107 wxLog::DontCreateOnDemand();
9108
9109 wxPyEndAllowThreads(__tstate);
9110 if (PyErr_Occurred()) SWIG_fail;
9111 }
9112 Py_INCREF(Py_None); resultobj = Py_None;
9113 return resultobj;
9114 fail:
9115 return NULL;
9116 }
9117
9118
9119 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9120 PyObject *resultobj;
9121 wxTraceMask arg1 ;
9122 PyObject * obj0 = 0 ;
9123 char *kwnames[] = {
9124 (char *) "ulMask", NULL
9125 };
9126
9127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9128 {
9129 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9130 if (SWIG_arg_fail(1)) SWIG_fail;
9131 }
9132 {
9133 PyThreadState* __tstate = wxPyBeginAllowThreads();
9134 wxLog::SetTraceMask(arg1);
9135
9136 wxPyEndAllowThreads(__tstate);
9137 if (PyErr_Occurred()) SWIG_fail;
9138 }
9139 Py_INCREF(Py_None); resultobj = Py_None;
9140 return resultobj;
9141 fail:
9142 return NULL;
9143 }
9144
9145
9146 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9147 PyObject *resultobj;
9148 wxString *arg1 = 0 ;
9149 bool temp1 = false ;
9150 PyObject * obj0 = 0 ;
9151 char *kwnames[] = {
9152 (char *) "str", NULL
9153 };
9154
9155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9156 {
9157 arg1 = wxString_in_helper(obj0);
9158 if (arg1 == NULL) SWIG_fail;
9159 temp1 = true;
9160 }
9161 {
9162 PyThreadState* __tstate = wxPyBeginAllowThreads();
9163 wxLog::AddTraceMask((wxString const &)*arg1);
9164
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 Py_INCREF(Py_None); resultobj = Py_None;
9169 {
9170 if (temp1)
9171 delete arg1;
9172 }
9173 return resultobj;
9174 fail:
9175 {
9176 if (temp1)
9177 delete arg1;
9178 }
9179 return NULL;
9180 }
9181
9182
9183 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj;
9185 wxString *arg1 = 0 ;
9186 bool temp1 = false ;
9187 PyObject * obj0 = 0 ;
9188 char *kwnames[] = {
9189 (char *) "str", NULL
9190 };
9191
9192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9193 {
9194 arg1 = wxString_in_helper(obj0);
9195 if (arg1 == NULL) SWIG_fail;
9196 temp1 = true;
9197 }
9198 {
9199 PyThreadState* __tstate = wxPyBeginAllowThreads();
9200 wxLog::RemoveTraceMask((wxString const &)*arg1);
9201
9202 wxPyEndAllowThreads(__tstate);
9203 if (PyErr_Occurred()) SWIG_fail;
9204 }
9205 Py_INCREF(Py_None); resultobj = Py_None;
9206 {
9207 if (temp1)
9208 delete arg1;
9209 }
9210 return resultobj;
9211 fail:
9212 {
9213 if (temp1)
9214 delete arg1;
9215 }
9216 return NULL;
9217 }
9218
9219
9220 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9221 PyObject *resultobj;
9222 char *kwnames[] = {
9223 NULL
9224 };
9225
9226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 wxLog::ClearTraceMasks();
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 Py_INCREF(Py_None); resultobj = Py_None;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj;
9243 wxArrayString *result;
9244 char *kwnames[] = {
9245 NULL
9246 };
9247
9248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9249 {
9250 PyThreadState* __tstate = wxPyBeginAllowThreads();
9251 {
9252 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9253 result = (wxArrayString *) &_result_ref;
9254 }
9255
9256 wxPyEndAllowThreads(__tstate);
9257 if (PyErr_Occurred()) SWIG_fail;
9258 }
9259 {
9260 resultobj = wxArrayString2PyList_helper(*result);
9261 }
9262 return resultobj;
9263 fail:
9264 return NULL;
9265 }
9266
9267
9268 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9269 PyObject *resultobj;
9270 wxChar *arg1 = (wxChar *) 0 ;
9271 PyObject * obj0 = 0 ;
9272 char *kwnames[] = {
9273 (char *) "ts", NULL
9274 };
9275
9276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9278 if (SWIG_arg_fail(1)) SWIG_fail;
9279 {
9280 PyThreadState* __tstate = wxPyBeginAllowThreads();
9281 wxLog::SetTimestamp((wxChar const *)arg1);
9282
9283 wxPyEndAllowThreads(__tstate);
9284 if (PyErr_Occurred()) SWIG_fail;
9285 }
9286 Py_INCREF(Py_None); resultobj = Py_None;
9287 return resultobj;
9288 fail:
9289 return NULL;
9290 }
9291
9292
9293 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9294 PyObject *resultobj;
9295 bool result;
9296 char *kwnames[] = {
9297 NULL
9298 };
9299
9300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9301 {
9302 PyThreadState* __tstate = wxPyBeginAllowThreads();
9303 result = (bool)wxLog::GetVerbose();
9304
9305 wxPyEndAllowThreads(__tstate);
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 {
9309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9310 }
9311 return resultobj;
9312 fail:
9313 return NULL;
9314 }
9315
9316
9317 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9318 PyObject *resultobj;
9319 wxTraceMask result;
9320 char *kwnames[] = {
9321 NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9325 {
9326 PyThreadState* __tstate = wxPyBeginAllowThreads();
9327 result = (wxTraceMask)wxLog::GetTraceMask();
9328
9329 wxPyEndAllowThreads(__tstate);
9330 if (PyErr_Occurred()) SWIG_fail;
9331 }
9332 {
9333 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9334 }
9335 return resultobj;
9336 fail:
9337 return NULL;
9338 }
9339
9340
9341 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9342 PyObject *resultobj;
9343 wxChar *arg1 = (wxChar *) 0 ;
9344 bool result;
9345 PyObject * obj0 = 0 ;
9346 char *kwnames[] = {
9347 (char *) "mask", NULL
9348 };
9349
9350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9352 if (SWIG_arg_fail(1)) SWIG_fail;
9353 {
9354 PyThreadState* __tstate = wxPyBeginAllowThreads();
9355 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9356
9357 wxPyEndAllowThreads(__tstate);
9358 if (PyErr_Occurred()) SWIG_fail;
9359 }
9360 {
9361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9362 }
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj;
9371 wxLogLevel result;
9372 char *kwnames[] = {
9373 NULL
9374 };
9375
9376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9377 {
9378 PyThreadState* __tstate = wxPyBeginAllowThreads();
9379 result = (wxLogLevel)wxLog::GetLogLevel();
9380
9381 wxPyEndAllowThreads(__tstate);
9382 if (PyErr_Occurred()) SWIG_fail;
9383 }
9384 {
9385 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9386 }
9387 return resultobj;
9388 fail:
9389 return NULL;
9390 }
9391
9392
9393 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9394 PyObject *resultobj;
9395 wxChar *result;
9396 char *kwnames[] = {
9397 NULL
9398 };
9399
9400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9401 {
9402 PyThreadState* __tstate = wxPyBeginAllowThreads();
9403 result = (wxChar *)wxLog::GetTimestamp();
9404
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9416 PyObject *resultobj;
9417 wxString result;
9418 char *kwnames[] = {
9419 NULL
9420 };
9421
9422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9423 {
9424 PyThreadState* __tstate = wxPyBeginAllowThreads();
9425 result = Log_TimeStamp();
9426
9427 wxPyEndAllowThreads(__tstate);
9428 if (PyErr_Occurred()) SWIG_fail;
9429 }
9430 {
9431 #if wxUSE_UNICODE
9432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9433 #else
9434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9435 #endif
9436 }
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9444 PyObject *resultobj;
9445 wxLog *arg1 = (wxLog *) 0 ;
9446 PyObject * obj0 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "self", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9453 if (SWIG_arg_fail(1)) SWIG_fail;
9454 {
9455 PyThreadState* __tstate = wxPyBeginAllowThreads();
9456 wxLog_Destroy(arg1);
9457
9458 wxPyEndAllowThreads(__tstate);
9459 if (PyErr_Occurred()) SWIG_fail;
9460 }
9461 Py_INCREF(Py_None); resultobj = Py_None;
9462 return resultobj;
9463 fail:
9464 return NULL;
9465 }
9466
9467
9468 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9469 PyObject *obj;
9470 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9471 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9472 Py_INCREF(obj);
9473 return Py_BuildValue((char *)"");
9474 }
9475 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9476 PyObject *resultobj;
9477 wxLogStderr *result;
9478 char *kwnames[] = {
9479 NULL
9480 };
9481
9482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9483 {
9484 PyThreadState* __tstate = wxPyBeginAllowThreads();
9485 result = (wxLogStderr *)new wxLogStderr();
9486
9487 wxPyEndAllowThreads(__tstate);
9488 if (PyErr_Occurred()) SWIG_fail;
9489 }
9490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9491 return resultobj;
9492 fail:
9493 return NULL;
9494 }
9495
9496
9497 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9498 PyObject *obj;
9499 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9500 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9501 Py_INCREF(obj);
9502 return Py_BuildValue((char *)"");
9503 }
9504 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9505 PyObject *resultobj;
9506 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9507 wxLogTextCtrl *result;
9508 PyObject * obj0 = 0 ;
9509 char *kwnames[] = {
9510 (char *) "pTextCtrl", NULL
9511 };
9512
9513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9515 if (SWIG_arg_fail(1)) SWIG_fail;
9516 {
9517 PyThreadState* __tstate = wxPyBeginAllowThreads();
9518 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9519
9520 wxPyEndAllowThreads(__tstate);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9531 PyObject *obj;
9532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9533 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9534 Py_INCREF(obj);
9535 return Py_BuildValue((char *)"");
9536 }
9537 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9538 PyObject *resultobj;
9539 wxLogGui *result;
9540 char *kwnames[] = {
9541 NULL
9542 };
9543
9544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9545 {
9546 PyThreadState* __tstate = wxPyBeginAllowThreads();
9547 result = (wxLogGui *)new wxLogGui();
9548
9549 wxPyEndAllowThreads(__tstate);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9560 PyObject *obj;
9561 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9562 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9563 Py_INCREF(obj);
9564 return Py_BuildValue((char *)"");
9565 }
9566 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9567 PyObject *resultobj;
9568 wxFrame *arg1 = (wxFrame *) 0 ;
9569 wxString *arg2 = 0 ;
9570 bool arg3 = (bool) true ;
9571 bool arg4 = (bool) true ;
9572 wxLogWindow *result;
9573 bool temp2 = false ;
9574 PyObject * obj0 = 0 ;
9575 PyObject * obj1 = 0 ;
9576 PyObject * obj2 = 0 ;
9577 PyObject * obj3 = 0 ;
9578 char *kwnames[] = {
9579 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9580 };
9581
9582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9584 if (SWIG_arg_fail(1)) SWIG_fail;
9585 {
9586 arg2 = wxString_in_helper(obj1);
9587 if (arg2 == NULL) SWIG_fail;
9588 temp2 = true;
9589 }
9590 if (obj2) {
9591 {
9592 arg3 = (bool)(SWIG_As_bool(obj2));
9593 if (SWIG_arg_fail(3)) SWIG_fail;
9594 }
9595 }
9596 if (obj3) {
9597 {
9598 arg4 = (bool)(SWIG_As_bool(obj3));
9599 if (SWIG_arg_fail(4)) SWIG_fail;
9600 }
9601 }
9602 {
9603 PyThreadState* __tstate = wxPyBeginAllowThreads();
9604 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9605
9606 wxPyEndAllowThreads(__tstate);
9607 if (PyErr_Occurred()) SWIG_fail;
9608 }
9609 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9610 {
9611 if (temp2)
9612 delete arg2;
9613 }
9614 return resultobj;
9615 fail:
9616 {
9617 if (temp2)
9618 delete arg2;
9619 }
9620 return NULL;
9621 }
9622
9623
9624 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9625 PyObject *resultobj;
9626 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9627 bool arg2 = (bool) true ;
9628 PyObject * obj0 = 0 ;
9629 PyObject * obj1 = 0 ;
9630 char *kwnames[] = {
9631 (char *) "self",(char *) "bShow", NULL
9632 };
9633
9634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9636 if (SWIG_arg_fail(1)) SWIG_fail;
9637 if (obj1) {
9638 {
9639 arg2 = (bool)(SWIG_As_bool(obj1));
9640 if (SWIG_arg_fail(2)) SWIG_fail;
9641 }
9642 }
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 (arg1)->Show(arg2);
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 Py_INCREF(Py_None); resultobj = Py_None;
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9660 wxFrame *result;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "self", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9668 if (SWIG_arg_fail(1)) SWIG_fail;
9669 {
9670 PyThreadState* __tstate = wxPyBeginAllowThreads();
9671 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9672
9673 wxPyEndAllowThreads(__tstate);
9674 if (PyErr_Occurred()) SWIG_fail;
9675 }
9676 {
9677 resultobj = wxPyMake_wxObject(result, 0);
9678 }
9679 return resultobj;
9680 fail:
9681 return NULL;
9682 }
9683
9684
9685 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj;
9687 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9688 wxLog *result;
9689 PyObject * obj0 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "self", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9696 if (SWIG_arg_fail(1)) SWIG_fail;
9697 {
9698 PyThreadState* __tstate = wxPyBeginAllowThreads();
9699 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9700
9701 wxPyEndAllowThreads(__tstate);
9702 if (PyErr_Occurred()) SWIG_fail;
9703 }
9704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9705 return resultobj;
9706 fail:
9707 return NULL;
9708 }
9709
9710
9711 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9712 PyObject *resultobj;
9713 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9714 bool result;
9715 PyObject * obj0 = 0 ;
9716 char *kwnames[] = {
9717 (char *) "self", NULL
9718 };
9719
9720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9722 if (SWIG_arg_fail(1)) SWIG_fail;
9723 {
9724 PyThreadState* __tstate = wxPyBeginAllowThreads();
9725 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9726
9727 wxPyEndAllowThreads(__tstate);
9728 if (PyErr_Occurred()) SWIG_fail;
9729 }
9730 {
9731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9732 }
9733 return resultobj;
9734 fail:
9735 return NULL;
9736 }
9737
9738
9739 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9740 PyObject *resultobj;
9741 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9742 bool arg2 ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "self",(char *) "bDoPass", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9751 if (SWIG_arg_fail(1)) SWIG_fail;
9752 {
9753 arg2 = (bool)(SWIG_As_bool(obj1));
9754 if (SWIG_arg_fail(2)) SWIG_fail;
9755 }
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 (arg1)->PassMessages(arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 return resultobj;
9765 fail:
9766 return NULL;
9767 }
9768
9769
9770 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9771 PyObject *obj;
9772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9773 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9774 Py_INCREF(obj);
9775 return Py_BuildValue((char *)"");
9776 }
9777 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9778 PyObject *resultobj;
9779 wxLog *arg1 = (wxLog *) 0 ;
9780 wxLogChain *result;
9781 PyObject * obj0 = 0 ;
9782 char *kwnames[] = {
9783 (char *) "logger", NULL
9784 };
9785
9786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9788 if (SWIG_arg_fail(1)) SWIG_fail;
9789 {
9790 PyThreadState* __tstate = wxPyBeginAllowThreads();
9791 result = (wxLogChain *)new wxLogChain(arg1);
9792
9793 wxPyEndAllowThreads(__tstate);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj;
9805 wxLogChain *arg1 = (wxLogChain *) 0 ;
9806 wxLog *arg2 = (wxLog *) 0 ;
9807 PyObject * obj0 = 0 ;
9808 PyObject * obj1 = 0 ;
9809 char *kwnames[] = {
9810 (char *) "self",(char *) "logger", NULL
9811 };
9812
9813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9815 if (SWIG_arg_fail(1)) SWIG_fail;
9816 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9817 if (SWIG_arg_fail(2)) SWIG_fail;
9818 {
9819 PyThreadState* __tstate = wxPyBeginAllowThreads();
9820 (arg1)->SetLog(arg2);
9821
9822 wxPyEndAllowThreads(__tstate);
9823 if (PyErr_Occurred()) SWIG_fail;
9824 }
9825 Py_INCREF(Py_None); resultobj = Py_None;
9826 return resultobj;
9827 fail:
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxLogChain *arg1 = (wxLogChain *) 0 ;
9835 bool arg2 ;
9836 PyObject * obj0 = 0 ;
9837 PyObject * obj1 = 0 ;
9838 char *kwnames[] = {
9839 (char *) "self",(char *) "bDoPass", NULL
9840 };
9841
9842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9844 if (SWIG_arg_fail(1)) SWIG_fail;
9845 {
9846 arg2 = (bool)(SWIG_As_bool(obj1));
9847 if (SWIG_arg_fail(2)) SWIG_fail;
9848 }
9849 {
9850 PyThreadState* __tstate = wxPyBeginAllowThreads();
9851 (arg1)->PassMessages(arg2);
9852
9853 wxPyEndAllowThreads(__tstate);
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 Py_INCREF(Py_None); resultobj = Py_None;
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9864 PyObject *resultobj;
9865 wxLogChain *arg1 = (wxLogChain *) 0 ;
9866 bool result;
9867 PyObject * obj0 = 0 ;
9868 char *kwnames[] = {
9869 (char *) "self", NULL
9870 };
9871
9872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9874 if (SWIG_arg_fail(1)) SWIG_fail;
9875 {
9876 PyThreadState* __tstate = wxPyBeginAllowThreads();
9877 result = (bool)(arg1)->IsPassingMessages();
9878
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 {
9883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9884 }
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj;
9893 wxLogChain *arg1 = (wxLogChain *) 0 ;
9894 wxLog *result;
9895 PyObject * obj0 = 0 ;
9896 char *kwnames[] = {
9897 (char *) "self", NULL
9898 };
9899
9900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9902 if (SWIG_arg_fail(1)) SWIG_fail;
9903 {
9904 PyThreadState* __tstate = wxPyBeginAllowThreads();
9905 result = (wxLog *)(arg1)->GetOldLog();
9906
9907 wxPyEndAllowThreads(__tstate);
9908 if (PyErr_Occurred()) SWIG_fail;
9909 }
9910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9918 PyObject *obj;
9919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9920 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9921 Py_INCREF(obj);
9922 return Py_BuildValue((char *)"");
9923 }
9924 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj;
9926 unsigned long result;
9927 char *kwnames[] = {
9928 NULL
9929 };
9930
9931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (unsigned long)wxSysErrorCode();
9935
9936 wxPyEndAllowThreads(__tstate);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 {
9940 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9941 }
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj;
9950 unsigned long arg1 = (unsigned long) 0 ;
9951 wxString result;
9952 PyObject * obj0 = 0 ;
9953 char *kwnames[] = {
9954 (char *) "nErrCode", NULL
9955 };
9956
9957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9958 if (obj0) {
9959 {
9960 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9961 if (SWIG_arg_fail(1)) SWIG_fail;
9962 }
9963 }
9964 {
9965 PyThreadState* __tstate = wxPyBeginAllowThreads();
9966 result = wxSysErrorMsg(arg1);
9967
9968 wxPyEndAllowThreads(__tstate);
9969 if (PyErr_Occurred()) SWIG_fail;
9970 }
9971 {
9972 #if wxUSE_UNICODE
9973 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9974 #else
9975 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9976 #endif
9977 }
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj;
9986 wxString *arg1 = 0 ;
9987 bool temp1 = false ;
9988 PyObject * obj0 = 0 ;
9989 char *kwnames[] = {
9990 (char *) "msg", NULL
9991 };
9992
9993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9994 {
9995 arg1 = wxString_in_helper(obj0);
9996 if (arg1 == NULL) SWIG_fail;
9997 temp1 = true;
9998 }
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 wxPyLogFatalError((wxString const &)*arg1);
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 Py_INCREF(Py_None); resultobj = Py_None;
10007 {
10008 if (temp1)
10009 delete arg1;
10010 }
10011 return resultobj;
10012 fail:
10013 {
10014 if (temp1)
10015 delete arg1;
10016 }
10017 return NULL;
10018 }
10019
10020
10021 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10022 PyObject *resultobj;
10023 wxString *arg1 = 0 ;
10024 bool temp1 = false ;
10025 PyObject * obj0 = 0 ;
10026 char *kwnames[] = {
10027 (char *) "msg", NULL
10028 };
10029
10030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10031 {
10032 arg1 = wxString_in_helper(obj0);
10033 if (arg1 == NULL) SWIG_fail;
10034 temp1 = true;
10035 }
10036 {
10037 PyThreadState* __tstate = wxPyBeginAllowThreads();
10038 wxPyLogError((wxString const &)*arg1);
10039
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 Py_INCREF(Py_None); resultobj = Py_None;
10044 {
10045 if (temp1)
10046 delete arg1;
10047 }
10048 return resultobj;
10049 fail:
10050 {
10051 if (temp1)
10052 delete arg1;
10053 }
10054 return NULL;
10055 }
10056
10057
10058 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj;
10060 wxString *arg1 = 0 ;
10061 bool temp1 = false ;
10062 PyObject * obj0 = 0 ;
10063 char *kwnames[] = {
10064 (char *) "msg", NULL
10065 };
10066
10067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10068 {
10069 arg1 = wxString_in_helper(obj0);
10070 if (arg1 == NULL) SWIG_fail;
10071 temp1 = true;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 wxPyLogWarning((wxString const &)*arg1);
10076
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 Py_INCREF(Py_None); resultobj = Py_None;
10081 {
10082 if (temp1)
10083 delete arg1;
10084 }
10085 return resultobj;
10086 fail:
10087 {
10088 if (temp1)
10089 delete arg1;
10090 }
10091 return NULL;
10092 }
10093
10094
10095 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10096 PyObject *resultobj;
10097 wxString *arg1 = 0 ;
10098 bool temp1 = false ;
10099 PyObject * obj0 = 0 ;
10100 char *kwnames[] = {
10101 (char *) "msg", NULL
10102 };
10103
10104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10105 {
10106 arg1 = wxString_in_helper(obj0);
10107 if (arg1 == NULL) SWIG_fail;
10108 temp1 = true;
10109 }
10110 {
10111 PyThreadState* __tstate = wxPyBeginAllowThreads();
10112 wxPyLogMessage((wxString const &)*arg1);
10113
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 Py_INCREF(Py_None); resultobj = Py_None;
10118 {
10119 if (temp1)
10120 delete arg1;
10121 }
10122 return resultobj;
10123 fail:
10124 {
10125 if (temp1)
10126 delete arg1;
10127 }
10128 return NULL;
10129 }
10130
10131
10132 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10133 PyObject *resultobj;
10134 wxString *arg1 = 0 ;
10135 bool temp1 = false ;
10136 PyObject * obj0 = 0 ;
10137 char *kwnames[] = {
10138 (char *) "msg", NULL
10139 };
10140
10141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10142 {
10143 arg1 = wxString_in_helper(obj0);
10144 if (arg1 == NULL) SWIG_fail;
10145 temp1 = true;
10146 }
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 wxPyLogInfo((wxString const &)*arg1);
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 Py_INCREF(Py_None); resultobj = Py_None;
10155 {
10156 if (temp1)
10157 delete arg1;
10158 }
10159 return resultobj;
10160 fail:
10161 {
10162 if (temp1)
10163 delete arg1;
10164 }
10165 return NULL;
10166 }
10167
10168
10169 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10170 PyObject *resultobj;
10171 wxString *arg1 = 0 ;
10172 bool temp1 = false ;
10173 PyObject * obj0 = 0 ;
10174 char *kwnames[] = {
10175 (char *) "msg", NULL
10176 };
10177
10178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10179 {
10180 arg1 = wxString_in_helper(obj0);
10181 if (arg1 == NULL) SWIG_fail;
10182 temp1 = true;
10183 }
10184 {
10185 PyThreadState* __tstate = wxPyBeginAllowThreads();
10186 wxPyLogDebug((wxString const &)*arg1);
10187
10188 wxPyEndAllowThreads(__tstate);
10189 if (PyErr_Occurred()) SWIG_fail;
10190 }
10191 Py_INCREF(Py_None); resultobj = Py_None;
10192 {
10193 if (temp1)
10194 delete arg1;
10195 }
10196 return resultobj;
10197 fail:
10198 {
10199 if (temp1)
10200 delete arg1;
10201 }
10202 return NULL;
10203 }
10204
10205
10206 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10207 PyObject *resultobj;
10208 wxString *arg1 = 0 ;
10209 bool temp1 = false ;
10210 PyObject * obj0 = 0 ;
10211 char *kwnames[] = {
10212 (char *) "msg", NULL
10213 };
10214
10215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10216 {
10217 arg1 = wxString_in_helper(obj0);
10218 if (arg1 == NULL) SWIG_fail;
10219 temp1 = true;
10220 }
10221 {
10222 PyThreadState* __tstate = wxPyBeginAllowThreads();
10223 wxPyLogVerbose((wxString const &)*arg1);
10224
10225 wxPyEndAllowThreads(__tstate);
10226 if (PyErr_Occurred()) SWIG_fail;
10227 }
10228 Py_INCREF(Py_None); resultobj = Py_None;
10229 {
10230 if (temp1)
10231 delete arg1;
10232 }
10233 return resultobj;
10234 fail:
10235 {
10236 if (temp1)
10237 delete arg1;
10238 }
10239 return NULL;
10240 }
10241
10242
10243 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10244 PyObject *resultobj;
10245 wxString *arg1 = 0 ;
10246 bool temp1 = false ;
10247 PyObject * obj0 = 0 ;
10248 char *kwnames[] = {
10249 (char *) "msg", NULL
10250 };
10251
10252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10253 {
10254 arg1 = wxString_in_helper(obj0);
10255 if (arg1 == NULL) SWIG_fail;
10256 temp1 = true;
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 wxPyLogStatus((wxString const &)*arg1);
10261
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 Py_INCREF(Py_None); resultobj = Py_None;
10266 {
10267 if (temp1)
10268 delete arg1;
10269 }
10270 return resultobj;
10271 fail:
10272 {
10273 if (temp1)
10274 delete arg1;
10275 }
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxFrame *arg1 = (wxFrame *) 0 ;
10283 wxString *arg2 = 0 ;
10284 bool temp2 = false ;
10285 PyObject * obj0 = 0 ;
10286 PyObject * obj1 = 0 ;
10287 char *kwnames[] = {
10288 (char *) "pFrame",(char *) "msg", NULL
10289 };
10290
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 {
10295 arg2 = wxString_in_helper(obj1);
10296 if (arg2 == NULL) SWIG_fail;
10297 temp2 = true;
10298 }
10299 {
10300 PyThreadState* __tstate = wxPyBeginAllowThreads();
10301 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10302
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 Py_INCREF(Py_None); resultobj = Py_None;
10307 {
10308 if (temp2)
10309 delete arg2;
10310 }
10311 return resultobj;
10312 fail:
10313 {
10314 if (temp2)
10315 delete arg2;
10316 }
10317 return NULL;
10318 }
10319
10320
10321 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj;
10323 wxString *arg1 = 0 ;
10324 bool temp1 = false ;
10325 PyObject * obj0 = 0 ;
10326 char *kwnames[] = {
10327 (char *) "msg", NULL
10328 };
10329
10330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10331 {
10332 arg1 = wxString_in_helper(obj0);
10333 if (arg1 == NULL) SWIG_fail;
10334 temp1 = true;
10335 }
10336 {
10337 PyThreadState* __tstate = wxPyBeginAllowThreads();
10338 wxPyLogSysError((wxString const &)*arg1);
10339
10340 wxPyEndAllowThreads(__tstate);
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 Py_INCREF(Py_None); resultobj = Py_None;
10344 {
10345 if (temp1)
10346 delete arg1;
10347 }
10348 return resultobj;
10349 fail:
10350 {
10351 if (temp1)
10352 delete arg1;
10353 }
10354 return NULL;
10355 }
10356
10357
10358 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj;
10360 unsigned long arg1 ;
10361 wxString *arg2 = 0 ;
10362 bool temp2 = false ;
10363 PyObject * obj0 = 0 ;
10364 PyObject * obj1 = 0 ;
10365 char *kwnames[] = {
10366 (char *) "level",(char *) "msg", NULL
10367 };
10368
10369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10370 {
10371 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10372 if (SWIG_arg_fail(1)) SWIG_fail;
10373 }
10374 {
10375 arg2 = wxString_in_helper(obj1);
10376 if (arg2 == NULL) SWIG_fail;
10377 temp2 = true;
10378 }
10379 {
10380 PyThreadState* __tstate = wxPyBeginAllowThreads();
10381 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10382
10383 wxPyEndAllowThreads(__tstate);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 Py_INCREF(Py_None); resultobj = Py_None;
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return resultobj;
10392 fail:
10393 {
10394 if (temp2)
10395 delete arg2;
10396 }
10397 return NULL;
10398 }
10399
10400
10401 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10402 PyObject *resultobj;
10403 unsigned long arg1 ;
10404 wxString *arg2 = 0 ;
10405 bool temp2 = false ;
10406 PyObject * obj0 = 0 ;
10407 PyObject * obj1 = 0 ;
10408
10409 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10410 {
10411 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10412 if (SWIG_arg_fail(1)) SWIG_fail;
10413 }
10414 {
10415 arg2 = wxString_in_helper(obj1);
10416 if (arg2 == NULL) SWIG_fail;
10417 temp2 = true;
10418 }
10419 {
10420 PyThreadState* __tstate = wxPyBeginAllowThreads();
10421 wxPyLogTrace(arg1,(wxString const &)*arg2);
10422
10423 wxPyEndAllowThreads(__tstate);
10424 if (PyErr_Occurred()) SWIG_fail;
10425 }
10426 Py_INCREF(Py_None); resultobj = Py_None;
10427 {
10428 if (temp2)
10429 delete arg2;
10430 }
10431 return resultobj;
10432 fail:
10433 {
10434 if (temp2)
10435 delete arg2;
10436 }
10437 return NULL;
10438 }
10439
10440
10441 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10442 PyObject *resultobj;
10443 wxString *arg1 = 0 ;
10444 wxString *arg2 = 0 ;
10445 bool temp1 = false ;
10446 bool temp2 = false ;
10447 PyObject * obj0 = 0 ;
10448 PyObject * obj1 = 0 ;
10449
10450 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10451 {
10452 arg1 = wxString_in_helper(obj0);
10453 if (arg1 == NULL) SWIG_fail;
10454 temp1 = true;
10455 }
10456 {
10457 arg2 = wxString_in_helper(obj1);
10458 if (arg2 == NULL) SWIG_fail;
10459 temp2 = true;
10460 }
10461 {
10462 PyThreadState* __tstate = wxPyBeginAllowThreads();
10463 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10464
10465 wxPyEndAllowThreads(__tstate);
10466 if (PyErr_Occurred()) SWIG_fail;
10467 }
10468 Py_INCREF(Py_None); resultobj = Py_None;
10469 {
10470 if (temp1)
10471 delete arg1;
10472 }
10473 {
10474 if (temp2)
10475 delete arg2;
10476 }
10477 return resultobj;
10478 fail:
10479 {
10480 if (temp1)
10481 delete arg1;
10482 }
10483 {
10484 if (temp2)
10485 delete arg2;
10486 }
10487 return NULL;
10488 }
10489
10490
10491 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10492 int argc;
10493 PyObject *argv[3];
10494 int ii;
10495
10496 argc = PyObject_Length(args);
10497 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10498 argv[ii] = PyTuple_GetItem(args,ii);
10499 }
10500 if (argc == 2) {
10501 int _v;
10502 {
10503 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10504 }
10505 if (_v) {
10506 {
10507 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10508 }
10509 if (_v) {
10510 return _wrap_LogTrace__SWIG_1(self,args);
10511 }
10512 }
10513 }
10514 if (argc == 2) {
10515 int _v;
10516 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10517 if (_v) {
10518 {
10519 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10520 }
10521 if (_v) {
10522 return _wrap_LogTrace__SWIG_0(self,args);
10523 }
10524 }
10525 }
10526
10527 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10528 return NULL;
10529 }
10530
10531
10532 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10533 PyObject *resultobj;
10534 wxString *arg1 = 0 ;
10535 wxString *arg2 = 0 ;
10536 bool temp1 = false ;
10537 bool temp2 = false ;
10538 PyObject * obj0 = 0 ;
10539 PyObject * obj1 = 0 ;
10540 char *kwnames[] = {
10541 (char *) "title",(char *) "text", NULL
10542 };
10543
10544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10545 {
10546 arg1 = wxString_in_helper(obj0);
10547 if (arg1 == NULL) SWIG_fail;
10548 temp1 = true;
10549 }
10550 {
10551 arg2 = wxString_in_helper(obj1);
10552 if (arg2 == NULL) SWIG_fail;
10553 temp2 = true;
10554 }
10555 {
10556 PyThreadState* __tstate = wxPyBeginAllowThreads();
10557 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10558
10559 wxPyEndAllowThreads(__tstate);
10560 if (PyErr_Occurred()) SWIG_fail;
10561 }
10562 Py_INCREF(Py_None); resultobj = Py_None;
10563 {
10564 if (temp1)
10565 delete arg1;
10566 }
10567 {
10568 if (temp2)
10569 delete arg2;
10570 }
10571 return resultobj;
10572 fail:
10573 {
10574 if (temp1)
10575 delete arg1;
10576 }
10577 {
10578 if (temp2)
10579 delete arg2;
10580 }
10581 return NULL;
10582 }
10583
10584
10585 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10586 PyObject *resultobj;
10587 wxLogNull *result;
10588 char *kwnames[] = {
10589 NULL
10590 };
10591
10592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10593 {
10594 PyThreadState* __tstate = wxPyBeginAllowThreads();
10595 result = (wxLogNull *)new wxLogNull();
10596
10597 wxPyEndAllowThreads(__tstate);
10598 if (PyErr_Occurred()) SWIG_fail;
10599 }
10600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10601 return resultobj;
10602 fail:
10603 return NULL;
10604 }
10605
10606
10607 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10608 PyObject *resultobj;
10609 wxLogNull *arg1 = (wxLogNull *) 0 ;
10610 PyObject * obj0 = 0 ;
10611 char *kwnames[] = {
10612 (char *) "self", NULL
10613 };
10614
10615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10617 if (SWIG_arg_fail(1)) SWIG_fail;
10618 {
10619 PyThreadState* __tstate = wxPyBeginAllowThreads();
10620 delete arg1;
10621
10622 wxPyEndAllowThreads(__tstate);
10623 if (PyErr_Occurred()) SWIG_fail;
10624 }
10625 Py_INCREF(Py_None); resultobj = Py_None;
10626 return resultobj;
10627 fail:
10628 return NULL;
10629 }
10630
10631
10632 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10633 PyObject *obj;
10634 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10635 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10636 Py_INCREF(obj);
10637 return Py_BuildValue((char *)"");
10638 }
10639 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10640 PyObject *resultobj;
10641 wxPyLog *result;
10642 char *kwnames[] = {
10643 NULL
10644 };
10645
10646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10647 {
10648 PyThreadState* __tstate = wxPyBeginAllowThreads();
10649 result = (wxPyLog *)new wxPyLog();
10650
10651 wxPyEndAllowThreads(__tstate);
10652 if (PyErr_Occurred()) SWIG_fail;
10653 }
10654 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10655 return resultobj;
10656 fail:
10657 return NULL;
10658 }
10659
10660
10661 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10662 PyObject *resultobj;
10663 wxPyLog *arg1 = (wxPyLog *) 0 ;
10664 PyObject *arg2 = (PyObject *) 0 ;
10665 PyObject *arg3 = (PyObject *) 0 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 PyObject * obj2 = 0 ;
10669 char *kwnames[] = {
10670 (char *) "self",(char *) "self",(char *) "_class", NULL
10671 };
10672
10673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10675 if (SWIG_arg_fail(1)) SWIG_fail;
10676 arg2 = obj1;
10677 arg3 = obj2;
10678 {
10679 PyThreadState* __tstate = wxPyBeginAllowThreads();
10680 (arg1)->_setCallbackInfo(arg2,arg3);
10681
10682 wxPyEndAllowThreads(__tstate);
10683 if (PyErr_Occurred()) SWIG_fail;
10684 }
10685 Py_INCREF(Py_None); resultobj = Py_None;
10686 return resultobj;
10687 fail:
10688 return NULL;
10689 }
10690
10691
10692 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10693 PyObject *obj;
10694 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10695 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10696 Py_INCREF(obj);
10697 return Py_BuildValue((char *)"");
10698 }
10699 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10700 PyObject *resultobj;
10701 int arg1 ;
10702 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10703 int arg3 = (int) wxKILL_NOCHILDREN ;
10704 wxKillError result;
10705 PyObject * obj0 = 0 ;
10706 PyObject * obj1 = 0 ;
10707 PyObject * obj2 = 0 ;
10708 char *kwnames[] = {
10709 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10710 };
10711
10712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10713 {
10714 arg1 = (int)(SWIG_As_int(obj0));
10715 if (SWIG_arg_fail(1)) SWIG_fail;
10716 }
10717 if (obj1) {
10718 {
10719 arg2 = (wxSignal)(SWIG_As_int(obj1));
10720 if (SWIG_arg_fail(2)) SWIG_fail;
10721 }
10722 }
10723 if (obj2) {
10724 {
10725 arg3 = (int)(SWIG_As_int(obj2));
10726 if (SWIG_arg_fail(3)) SWIG_fail;
10727 }
10728 }
10729 {
10730 PyThreadState* __tstate = wxPyBeginAllowThreads();
10731 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10732
10733 wxPyEndAllowThreads(__tstate);
10734 if (PyErr_Occurred()) SWIG_fail;
10735 }
10736 resultobj = SWIG_From_int((result));
10737 return resultobj;
10738 fail:
10739 return NULL;
10740 }
10741
10742
10743 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10744 PyObject *resultobj;
10745 int arg1 ;
10746 bool result;
10747 PyObject * obj0 = 0 ;
10748 char *kwnames[] = {
10749 (char *) "pid", NULL
10750 };
10751
10752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10753 {
10754 arg1 = (int)(SWIG_As_int(obj0));
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 }
10757 {
10758 PyThreadState* __tstate = wxPyBeginAllowThreads();
10759 result = (bool)wxPyProcess::Exists(arg1);
10760
10761 wxPyEndAllowThreads(__tstate);
10762 if (PyErr_Occurred()) SWIG_fail;
10763 }
10764 {
10765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10766 }
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj;
10775 wxString *arg1 = 0 ;
10776 int arg2 = (int) wxEXEC_ASYNC ;
10777 wxPyProcess *result;
10778 bool temp1 = false ;
10779 PyObject * obj0 = 0 ;
10780 PyObject * obj1 = 0 ;
10781 char *kwnames[] = {
10782 (char *) "cmd",(char *) "flags", NULL
10783 };
10784
10785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10786 {
10787 arg1 = wxString_in_helper(obj0);
10788 if (arg1 == NULL) SWIG_fail;
10789 temp1 = true;
10790 }
10791 if (obj1) {
10792 {
10793 arg2 = (int)(SWIG_As_int(obj1));
10794 if (SWIG_arg_fail(2)) SWIG_fail;
10795 }
10796 }
10797 {
10798 PyThreadState* __tstate = wxPyBeginAllowThreads();
10799 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10800
10801 wxPyEndAllowThreads(__tstate);
10802 if (PyErr_Occurred()) SWIG_fail;
10803 }
10804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10805 {
10806 if (temp1)
10807 delete arg1;
10808 }
10809 return resultobj;
10810 fail:
10811 {
10812 if (temp1)
10813 delete arg1;
10814 }
10815 return NULL;
10816 }
10817
10818
10819 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj;
10821 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10822 int arg2 = (int) -1 ;
10823 wxPyProcess *result;
10824 PyObject * obj0 = 0 ;
10825 PyObject * obj1 = 0 ;
10826 char *kwnames[] = {
10827 (char *) "parent",(char *) "id", NULL
10828 };
10829
10830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10831 if (obj0) {
10832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10833 if (SWIG_arg_fail(1)) SWIG_fail;
10834 }
10835 if (obj1) {
10836 {
10837 arg2 = (int)(SWIG_As_int(obj1));
10838 if (SWIG_arg_fail(2)) SWIG_fail;
10839 }
10840 }
10841 {
10842 PyThreadState* __tstate = wxPyBeginAllowThreads();
10843 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10844
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj;
10857 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10858 PyObject *arg2 = (PyObject *) 0 ;
10859 PyObject *arg3 = (PyObject *) 0 ;
10860 PyObject * obj0 = 0 ;
10861 PyObject * obj1 = 0 ;
10862 PyObject * obj2 = 0 ;
10863 char *kwnames[] = {
10864 (char *) "self",(char *) "self",(char *) "_class", NULL
10865 };
10866
10867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10869 if (SWIG_arg_fail(1)) SWIG_fail;
10870 arg2 = obj1;
10871 arg3 = obj2;
10872 {
10873 PyThreadState* __tstate = wxPyBeginAllowThreads();
10874 (arg1)->_setCallbackInfo(arg2,arg3);
10875
10876 wxPyEndAllowThreads(__tstate);
10877 if (PyErr_Occurred()) SWIG_fail;
10878 }
10879 Py_INCREF(Py_None); resultobj = Py_None;
10880 return resultobj;
10881 fail:
10882 return NULL;
10883 }
10884
10885
10886 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10887 PyObject *resultobj;
10888 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10889 int arg2 ;
10890 int arg3 ;
10891 PyObject * obj0 = 0 ;
10892 PyObject * obj1 = 0 ;
10893 PyObject * obj2 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "self",(char *) "pid",(char *) "status", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10900 if (SWIG_arg_fail(1)) SWIG_fail;
10901 {
10902 arg2 = (int)(SWIG_As_int(obj1));
10903 if (SWIG_arg_fail(2)) SWIG_fail;
10904 }
10905 {
10906 arg3 = (int)(SWIG_As_int(obj2));
10907 if (SWIG_arg_fail(3)) SWIG_fail;
10908 }
10909 {
10910 PyThreadState* __tstate = wxPyBeginAllowThreads();
10911 (arg1)->base_OnTerminate(arg2,arg3);
10912
10913 wxPyEndAllowThreads(__tstate);
10914 if (PyErr_Occurred()) SWIG_fail;
10915 }
10916 Py_INCREF(Py_None); resultobj = Py_None;
10917 return resultobj;
10918 fail:
10919 return NULL;
10920 }
10921
10922
10923 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10924 PyObject *resultobj;
10925 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10926 PyObject * obj0 = 0 ;
10927 char *kwnames[] = {
10928 (char *) "self", NULL
10929 };
10930
10931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10933 if (SWIG_arg_fail(1)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 (arg1)->Redirect();
10937
10938 wxPyEndAllowThreads(__tstate);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 Py_INCREF(Py_None); resultobj = Py_None;
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj;
10950 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10951 bool result;
10952 PyObject * obj0 = 0 ;
10953 char *kwnames[] = {
10954 (char *) "self", NULL
10955 };
10956
10957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10959 if (SWIG_arg_fail(1)) SWIG_fail;
10960 {
10961 PyThreadState* __tstate = wxPyBeginAllowThreads();
10962 result = (bool)(arg1)->IsRedirected();
10963
10964 wxPyEndAllowThreads(__tstate);
10965 if (PyErr_Occurred()) SWIG_fail;
10966 }
10967 {
10968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10969 }
10970 return resultobj;
10971 fail:
10972 return NULL;
10973 }
10974
10975
10976 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10977 PyObject *resultobj;
10978 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10979 PyObject * obj0 = 0 ;
10980 char *kwnames[] = {
10981 (char *) "self", NULL
10982 };
10983
10984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10986 if (SWIG_arg_fail(1)) SWIG_fail;
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 (arg1)->Detach();
10990
10991 wxPyEndAllowThreads(__tstate);
10992 if (PyErr_Occurred()) SWIG_fail;
10993 }
10994 Py_INCREF(Py_None); resultobj = Py_None;
10995 return resultobj;
10996 fail:
10997 return NULL;
10998 }
10999
11000
11001 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11002 PyObject *resultobj;
11003 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11004 wxInputStream *result;
11005 PyObject * obj0 = 0 ;
11006 char *kwnames[] = {
11007 (char *) "self", NULL
11008 };
11009
11010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11012 if (SWIG_arg_fail(1)) SWIG_fail;
11013 {
11014 PyThreadState* __tstate = wxPyBeginAllowThreads();
11015 result = (wxInputStream *)(arg1)->GetInputStream();
11016
11017 wxPyEndAllowThreads(__tstate);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 {
11021 wxPyInputStream * _ptr = NULL;
11022
11023 if (result) {
11024 _ptr = new wxPyInputStream(result);
11025 }
11026 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11027 }
11028 return resultobj;
11029 fail:
11030 return NULL;
11031 }
11032
11033
11034 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11035 PyObject *resultobj;
11036 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11037 wxInputStream *result;
11038 PyObject * obj0 = 0 ;
11039 char *kwnames[] = {
11040 (char *) "self", NULL
11041 };
11042
11043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11045 if (SWIG_arg_fail(1)) SWIG_fail;
11046 {
11047 PyThreadState* __tstate = wxPyBeginAllowThreads();
11048 result = (wxInputStream *)(arg1)->GetErrorStream();
11049
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 wxPyInputStream * _ptr = NULL;
11055
11056 if (result) {
11057 _ptr = new wxPyInputStream(result);
11058 }
11059 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11060 }
11061 return resultobj;
11062 fail:
11063 return NULL;
11064 }
11065
11066
11067 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj;
11069 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11070 wxOutputStream *result;
11071 PyObject * obj0 = 0 ;
11072 char *kwnames[] = {
11073 (char *) "self", NULL
11074 };
11075
11076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11078 if (SWIG_arg_fail(1)) SWIG_fail;
11079 {
11080 PyThreadState* __tstate = wxPyBeginAllowThreads();
11081 result = (wxOutputStream *)(arg1)->GetOutputStream();
11082
11083 wxPyEndAllowThreads(__tstate);
11084 if (PyErr_Occurred()) SWIG_fail;
11085 }
11086 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11087 return resultobj;
11088 fail:
11089 return NULL;
11090 }
11091
11092
11093 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11094 PyObject *resultobj;
11095 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11096 PyObject * obj0 = 0 ;
11097 char *kwnames[] = {
11098 (char *) "self", NULL
11099 };
11100
11101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11103 if (SWIG_arg_fail(1)) SWIG_fail;
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 (arg1)->CloseOutput();
11107
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 Py_INCREF(Py_None); resultobj = Py_None;
11112 return resultobj;
11113 fail:
11114 return NULL;
11115 }
11116
11117
11118 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11119 PyObject *resultobj;
11120 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11121 bool result;
11122 PyObject * obj0 = 0 ;
11123 char *kwnames[] = {
11124 (char *) "self", NULL
11125 };
11126
11127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11129 if (SWIG_arg_fail(1)) SWIG_fail;
11130 {
11131 PyThreadState* __tstate = wxPyBeginAllowThreads();
11132 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11133
11134 wxPyEndAllowThreads(__tstate);
11135 if (PyErr_Occurred()) SWIG_fail;
11136 }
11137 {
11138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11139 }
11140 return resultobj;
11141 fail:
11142 return NULL;
11143 }
11144
11145
11146 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11147 PyObject *resultobj;
11148 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11149 bool result;
11150 PyObject * obj0 = 0 ;
11151 char *kwnames[] = {
11152 (char *) "self", NULL
11153 };
11154
11155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11157 if (SWIG_arg_fail(1)) SWIG_fail;
11158 {
11159 PyThreadState* __tstate = wxPyBeginAllowThreads();
11160 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11161
11162 wxPyEndAllowThreads(__tstate);
11163 if (PyErr_Occurred()) SWIG_fail;
11164 }
11165 {
11166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11167 }
11168 return resultobj;
11169 fail:
11170 return NULL;
11171 }
11172
11173
11174 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11175 PyObject *resultobj;
11176 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11177 bool result;
11178 PyObject * obj0 = 0 ;
11179 char *kwnames[] = {
11180 (char *) "self", NULL
11181 };
11182
11183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11185 if (SWIG_arg_fail(1)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11189
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11195 }
11196 return resultobj;
11197 fail:
11198 return NULL;
11199 }
11200
11201
11202 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11203 PyObject *obj;
11204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11205 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11206 Py_INCREF(obj);
11207 return Py_BuildValue((char *)"");
11208 }
11209 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj;
11211 int arg1 = (int) 0 ;
11212 int arg2 = (int) 0 ;
11213 int arg3 = (int) 0 ;
11214 wxProcessEvent *result;
11215 PyObject * obj0 = 0 ;
11216 PyObject * obj1 = 0 ;
11217 PyObject * obj2 = 0 ;
11218 char *kwnames[] = {
11219 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11220 };
11221
11222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11223 if (obj0) {
11224 {
11225 arg1 = (int)(SWIG_As_int(obj0));
11226 if (SWIG_arg_fail(1)) SWIG_fail;
11227 }
11228 }
11229 if (obj1) {
11230 {
11231 arg2 = (int)(SWIG_As_int(obj1));
11232 if (SWIG_arg_fail(2)) SWIG_fail;
11233 }
11234 }
11235 if (obj2) {
11236 {
11237 arg3 = (int)(SWIG_As_int(obj2));
11238 if (SWIG_arg_fail(3)) SWIG_fail;
11239 }
11240 }
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11244
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11249 return resultobj;
11250 fail:
11251 return NULL;
11252 }
11253
11254
11255 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11256 PyObject *resultobj;
11257 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11258 int result;
11259 PyObject * obj0 = 0 ;
11260 char *kwnames[] = {
11261 (char *) "self", NULL
11262 };
11263
11264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11266 if (SWIG_arg_fail(1)) SWIG_fail;
11267 {
11268 PyThreadState* __tstate = wxPyBeginAllowThreads();
11269 result = (int)(arg1)->GetPid();
11270
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 {
11275 resultobj = SWIG_From_int((int)(result));
11276 }
11277 return resultobj;
11278 fail:
11279 return NULL;
11280 }
11281
11282
11283 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11284 PyObject *resultobj;
11285 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11286 int result;
11287 PyObject * obj0 = 0 ;
11288 char *kwnames[] = {
11289 (char *) "self", NULL
11290 };
11291
11292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11294 if (SWIG_arg_fail(1)) SWIG_fail;
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 result = (int)(arg1)->GetExitCode();
11298
11299 wxPyEndAllowThreads(__tstate);
11300 if (PyErr_Occurred()) SWIG_fail;
11301 }
11302 {
11303 resultobj = SWIG_From_int((int)(result));
11304 }
11305 return resultobj;
11306 fail:
11307 return NULL;
11308 }
11309
11310
11311 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11312 PyObject *resultobj;
11313 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11314 int arg2 ;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 char *kwnames[] = {
11318 (char *) "self",(char *) "m_pid", NULL
11319 };
11320
11321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11323 if (SWIG_arg_fail(1)) SWIG_fail;
11324 {
11325 arg2 = (int)(SWIG_As_int(obj1));
11326 if (SWIG_arg_fail(2)) SWIG_fail;
11327 }
11328 if (arg1) (arg1)->m_pid = arg2;
11329
11330 Py_INCREF(Py_None); resultobj = Py_None;
11331 return resultobj;
11332 fail:
11333 return NULL;
11334 }
11335
11336
11337 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11338 PyObject *resultobj;
11339 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11340 int result;
11341 PyObject * obj0 = 0 ;
11342 char *kwnames[] = {
11343 (char *) "self", NULL
11344 };
11345
11346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 result = (int) ((arg1)->m_pid);
11350
11351 {
11352 resultobj = SWIG_From_int((int)(result));
11353 }
11354 return resultobj;
11355 fail:
11356 return NULL;
11357 }
11358
11359
11360 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11361 PyObject *resultobj;
11362 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11363 int arg2 ;
11364 PyObject * obj0 = 0 ;
11365 PyObject * obj1 = 0 ;
11366 char *kwnames[] = {
11367 (char *) "self",(char *) "m_exitcode", NULL
11368 };
11369
11370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11372 if (SWIG_arg_fail(1)) SWIG_fail;
11373 {
11374 arg2 = (int)(SWIG_As_int(obj1));
11375 if (SWIG_arg_fail(2)) SWIG_fail;
11376 }
11377 if (arg1) (arg1)->m_exitcode = arg2;
11378
11379 Py_INCREF(Py_None); resultobj = Py_None;
11380 return resultobj;
11381 fail:
11382 return NULL;
11383 }
11384
11385
11386 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11387 PyObject *resultobj;
11388 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11389 int result;
11390 PyObject * obj0 = 0 ;
11391 char *kwnames[] = {
11392 (char *) "self", NULL
11393 };
11394
11395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11397 if (SWIG_arg_fail(1)) SWIG_fail;
11398 result = (int) ((arg1)->m_exitcode);
11399
11400 {
11401 resultobj = SWIG_From_int((int)(result));
11402 }
11403 return resultobj;
11404 fail:
11405 return NULL;
11406 }
11407
11408
11409 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11410 PyObject *obj;
11411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11412 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11413 Py_INCREF(obj);
11414 return Py_BuildValue((char *)"");
11415 }
11416 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxString *arg1 = 0 ;
11419 int arg2 = (int) wxEXEC_ASYNC ;
11420 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11421 long result;
11422 bool temp1 = false ;
11423 PyObject * obj0 = 0 ;
11424 PyObject * obj1 = 0 ;
11425 PyObject * obj2 = 0 ;
11426 char *kwnames[] = {
11427 (char *) "command",(char *) "flags",(char *) "process", NULL
11428 };
11429
11430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11431 {
11432 arg1 = wxString_in_helper(obj0);
11433 if (arg1 == NULL) SWIG_fail;
11434 temp1 = true;
11435 }
11436 if (obj1) {
11437 {
11438 arg2 = (int)(SWIG_As_int(obj1));
11439 if (SWIG_arg_fail(2)) SWIG_fail;
11440 }
11441 }
11442 if (obj2) {
11443 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11444 if (SWIG_arg_fail(3)) SWIG_fail;
11445 }
11446 {
11447 if (!wxPyCheckForApp()) SWIG_fail;
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11450
11451 wxPyEndAllowThreads(__tstate);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 {
11455 resultobj = SWIG_From_long((long)(result));
11456 }
11457 {
11458 if (temp1)
11459 delete arg1;
11460 }
11461 return resultobj;
11462 fail:
11463 {
11464 if (temp1)
11465 delete arg1;
11466 }
11467 return NULL;
11468 }
11469
11470
11471 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11472 PyObject *resultobj;
11473 long arg1 ;
11474 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11475 wxKillError *arg3 = (wxKillError *) 0 ;
11476 int arg4 = (int) wxKILL_NOCHILDREN ;
11477 int result;
11478 wxKillError temp3 ;
11479 PyObject * obj0 = 0 ;
11480 PyObject * obj1 = 0 ;
11481 PyObject * obj2 = 0 ;
11482 char *kwnames[] = {
11483 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11484 };
11485
11486 {
11487 arg3 = &temp3;
11488 }
11489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11490 {
11491 arg1 = (long)(SWIG_As_long(obj0));
11492 if (SWIG_arg_fail(1)) SWIG_fail;
11493 }
11494 if (obj1) {
11495 {
11496 arg2 = (wxSignal)(SWIG_As_int(obj1));
11497 if (SWIG_arg_fail(2)) SWIG_fail;
11498 }
11499 }
11500 if (obj2) {
11501 {
11502 arg4 = (int)(SWIG_As_int(obj2));
11503 if (SWIG_arg_fail(4)) SWIG_fail;
11504 }
11505 }
11506 {
11507 PyThreadState* __tstate = wxPyBeginAllowThreads();
11508 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11509
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 {
11514 resultobj = SWIG_From_int((int)(result));
11515 }
11516 {
11517 PyObject* o;
11518 o = PyInt_FromLong((long) (*arg3));
11519 resultobj = t_output_helper(resultobj, o);
11520 }
11521 return resultobj;
11522 fail:
11523 return NULL;
11524 }
11525
11526
11527 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11528 PyObject *resultobj;
11529 int arg1 = (int) wxJOYSTICK1 ;
11530 wxJoystick *result;
11531 PyObject * obj0 = 0 ;
11532 char *kwnames[] = {
11533 (char *) "joystick", NULL
11534 };
11535
11536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11537 if (obj0) {
11538 {
11539 arg1 = (int)(SWIG_As_int(obj0));
11540 if (SWIG_arg_fail(1)) SWIG_fail;
11541 }
11542 }
11543 {
11544 if (!wxPyCheckForApp()) SWIG_fail;
11545 PyThreadState* __tstate = wxPyBeginAllowThreads();
11546 result = (wxJoystick *)new wxJoystick(arg1);
11547
11548 wxPyEndAllowThreads(__tstate);
11549 if (PyErr_Occurred()) SWIG_fail;
11550 }
11551 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11552 return resultobj;
11553 fail:
11554 return NULL;
11555 }
11556
11557
11558 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj;
11560 wxJoystick *arg1 = (wxJoystick *) 0 ;
11561 PyObject * obj0 = 0 ;
11562 char *kwnames[] = {
11563 (char *) "self", NULL
11564 };
11565
11566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11568 if (SWIG_arg_fail(1)) SWIG_fail;
11569 {
11570 PyThreadState* __tstate = wxPyBeginAllowThreads();
11571 delete arg1;
11572
11573 wxPyEndAllowThreads(__tstate);
11574 if (PyErr_Occurred()) SWIG_fail;
11575 }
11576 Py_INCREF(Py_None); resultobj = Py_None;
11577 return resultobj;
11578 fail:
11579 return NULL;
11580 }
11581
11582
11583 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11584 PyObject *resultobj;
11585 wxJoystick *arg1 = (wxJoystick *) 0 ;
11586 wxPoint result;
11587 PyObject * obj0 = 0 ;
11588 char *kwnames[] = {
11589 (char *) "self", NULL
11590 };
11591
11592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11594 if (SWIG_arg_fail(1)) SWIG_fail;
11595 {
11596 PyThreadState* __tstate = wxPyBeginAllowThreads();
11597 result = (arg1)->GetPosition();
11598
11599 wxPyEndAllowThreads(__tstate);
11600 if (PyErr_Occurred()) SWIG_fail;
11601 }
11602 {
11603 wxPoint * resultptr;
11604 resultptr = new wxPoint((wxPoint &)(result));
11605 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11606 }
11607 return resultobj;
11608 fail:
11609 return NULL;
11610 }
11611
11612
11613 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11614 PyObject *resultobj;
11615 wxJoystick *arg1 = (wxJoystick *) 0 ;
11616 int result;
11617 PyObject * obj0 = 0 ;
11618 char *kwnames[] = {
11619 (char *) "self", NULL
11620 };
11621
11622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11624 if (SWIG_arg_fail(1)) SWIG_fail;
11625 {
11626 PyThreadState* __tstate = wxPyBeginAllowThreads();
11627 result = (int)(arg1)->GetZPosition();
11628
11629 wxPyEndAllowThreads(__tstate);
11630 if (PyErr_Occurred()) SWIG_fail;
11631 }
11632 {
11633 resultobj = SWIG_From_int((int)(result));
11634 }
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj;
11643 wxJoystick *arg1 = (wxJoystick *) 0 ;
11644 int result;
11645 PyObject * obj0 = 0 ;
11646 char *kwnames[] = {
11647 (char *) "self", NULL
11648 };
11649
11650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11652 if (SWIG_arg_fail(1)) SWIG_fail;
11653 {
11654 PyThreadState* __tstate = wxPyBeginAllowThreads();
11655 result = (int)(arg1)->GetButtonState();
11656
11657 wxPyEndAllowThreads(__tstate);
11658 if (PyErr_Occurred()) SWIG_fail;
11659 }
11660 {
11661 resultobj = SWIG_From_int((int)(result));
11662 }
11663 return resultobj;
11664 fail:
11665 return NULL;
11666 }
11667
11668
11669 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11670 PyObject *resultobj;
11671 wxJoystick *arg1 = (wxJoystick *) 0 ;
11672 int result;
11673 PyObject * obj0 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (int)(arg1)->GetPOVPosition();
11684
11685 wxPyEndAllowThreads(__tstate);
11686 if (PyErr_Occurred()) SWIG_fail;
11687 }
11688 {
11689 resultobj = SWIG_From_int((int)(result));
11690 }
11691 return resultobj;
11692 fail:
11693 return NULL;
11694 }
11695
11696
11697 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11698 PyObject *resultobj;
11699 wxJoystick *arg1 = (wxJoystick *) 0 ;
11700 int result;
11701 PyObject * obj0 = 0 ;
11702 char *kwnames[] = {
11703 (char *) "self", NULL
11704 };
11705
11706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11708 if (SWIG_arg_fail(1)) SWIG_fail;
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (int)(arg1)->GetPOVCTSPosition();
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = SWIG_From_int((int)(result));
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11726 PyObject *resultobj;
11727 wxJoystick *arg1 = (wxJoystick *) 0 ;
11728 int result;
11729 PyObject * obj0 = 0 ;
11730 char *kwnames[] = {
11731 (char *) "self", NULL
11732 };
11733
11734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11736 if (SWIG_arg_fail(1)) SWIG_fail;
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->GetRudderPosition();
11740
11741 wxPyEndAllowThreads(__tstate);
11742 if (PyErr_Occurred()) SWIG_fail;
11743 }
11744 {
11745 resultobj = SWIG_From_int((int)(result));
11746 }
11747 return resultobj;
11748 fail:
11749 return NULL;
11750 }
11751
11752
11753 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11754 PyObject *resultobj;
11755 wxJoystick *arg1 = (wxJoystick *) 0 ;
11756 int result;
11757 PyObject * obj0 = 0 ;
11758 char *kwnames[] = {
11759 (char *) "self", NULL
11760 };
11761
11762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11764 if (SWIG_arg_fail(1)) SWIG_fail;
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (int)(arg1)->GetUPosition();
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = SWIG_From_int((int)(result));
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj;
11783 wxJoystick *arg1 = (wxJoystick *) 0 ;
11784 int result;
11785 PyObject * obj0 = 0 ;
11786 char *kwnames[] = {
11787 (char *) "self", NULL
11788 };
11789
11790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11792 if (SWIG_arg_fail(1)) SWIG_fail;
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (int)(arg1)->GetVPosition();
11796
11797 wxPyEndAllowThreads(__tstate);
11798 if (PyErr_Occurred()) SWIG_fail;
11799 }
11800 {
11801 resultobj = SWIG_From_int((int)(result));
11802 }
11803 return resultobj;
11804 fail:
11805 return NULL;
11806 }
11807
11808
11809 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11810 PyObject *resultobj;
11811 wxJoystick *arg1 = (wxJoystick *) 0 ;
11812 int result;
11813 PyObject * obj0 = 0 ;
11814 char *kwnames[] = {
11815 (char *) "self", NULL
11816 };
11817
11818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11820 if (SWIG_arg_fail(1)) SWIG_fail;
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (int)(arg1)->GetMovementThreshold();
11824
11825 wxPyEndAllowThreads(__tstate);
11826 if (PyErr_Occurred()) SWIG_fail;
11827 }
11828 {
11829 resultobj = SWIG_From_int((int)(result));
11830 }
11831 return resultobj;
11832 fail:
11833 return NULL;
11834 }
11835
11836
11837 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11838 PyObject *resultobj;
11839 wxJoystick *arg1 = (wxJoystick *) 0 ;
11840 int arg2 ;
11841 PyObject * obj0 = 0 ;
11842 PyObject * obj1 = 0 ;
11843 char *kwnames[] = {
11844 (char *) "self",(char *) "threshold", NULL
11845 };
11846
11847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11849 if (SWIG_arg_fail(1)) SWIG_fail;
11850 {
11851 arg2 = (int)(SWIG_As_int(obj1));
11852 if (SWIG_arg_fail(2)) SWIG_fail;
11853 }
11854 {
11855 PyThreadState* __tstate = wxPyBeginAllowThreads();
11856 (arg1)->SetMovementThreshold(arg2);
11857
11858 wxPyEndAllowThreads(__tstate);
11859 if (PyErr_Occurred()) SWIG_fail;
11860 }
11861 Py_INCREF(Py_None); resultobj = Py_None;
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj;
11870 wxJoystick *arg1 = (wxJoystick *) 0 ;
11871 bool result;
11872 PyObject * obj0 = 0 ;
11873 char *kwnames[] = {
11874 (char *) "self", NULL
11875 };
11876
11877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11879 if (SWIG_arg_fail(1)) SWIG_fail;
11880 {
11881 PyThreadState* __tstate = wxPyBeginAllowThreads();
11882 result = (bool)(arg1)->IsOk();
11883
11884 wxPyEndAllowThreads(__tstate);
11885 if (PyErr_Occurred()) SWIG_fail;
11886 }
11887 {
11888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11889 }
11890 return resultobj;
11891 fail:
11892 return NULL;
11893 }
11894
11895
11896 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11897 PyObject *resultobj;
11898 wxJoystick *arg1 = (wxJoystick *) 0 ;
11899 int result;
11900 PyObject * obj0 = 0 ;
11901 char *kwnames[] = {
11902 (char *) "self", NULL
11903 };
11904
11905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11907 if (SWIG_arg_fail(1)) SWIG_fail;
11908 {
11909 PyThreadState* __tstate = wxPyBeginAllowThreads();
11910 result = (int)(arg1)->GetNumberJoysticks();
11911
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 resultobj = SWIG_From_int((int)(result));
11917 }
11918 return resultobj;
11919 fail:
11920 return NULL;
11921 }
11922
11923
11924 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11925 PyObject *resultobj;
11926 wxJoystick *arg1 = (wxJoystick *) 0 ;
11927 int result;
11928 PyObject * obj0 = 0 ;
11929 char *kwnames[] = {
11930 (char *) "self", NULL
11931 };
11932
11933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11935 if (SWIG_arg_fail(1)) SWIG_fail;
11936 {
11937 PyThreadState* __tstate = wxPyBeginAllowThreads();
11938 result = (int)(arg1)->GetManufacturerId();
11939
11940 wxPyEndAllowThreads(__tstate);
11941 if (PyErr_Occurred()) SWIG_fail;
11942 }
11943 {
11944 resultobj = SWIG_From_int((int)(result));
11945 }
11946 return resultobj;
11947 fail:
11948 return NULL;
11949 }
11950
11951
11952 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11953 PyObject *resultobj;
11954 wxJoystick *arg1 = (wxJoystick *) 0 ;
11955 int result;
11956 PyObject * obj0 = 0 ;
11957 char *kwnames[] = {
11958 (char *) "self", NULL
11959 };
11960
11961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11963 if (SWIG_arg_fail(1)) SWIG_fail;
11964 {
11965 PyThreadState* __tstate = wxPyBeginAllowThreads();
11966 result = (int)(arg1)->GetProductId();
11967
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 resultobj = SWIG_From_int((int)(result));
11973 }
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj;
11982 wxJoystick *arg1 = (wxJoystick *) 0 ;
11983 wxString result;
11984 PyObject * obj0 = 0 ;
11985 char *kwnames[] = {
11986 (char *) "self", NULL
11987 };
11988
11989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11991 if (SWIG_arg_fail(1)) SWIG_fail;
11992 {
11993 PyThreadState* __tstate = wxPyBeginAllowThreads();
11994 result = (arg1)->GetProductName();
11995
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 {
12000 #if wxUSE_UNICODE
12001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12002 #else
12003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12004 #endif
12005 }
12006 return resultobj;
12007 fail:
12008 return NULL;
12009 }
12010
12011
12012 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12013 PyObject *resultobj;
12014 wxJoystick *arg1 = (wxJoystick *) 0 ;
12015 int result;
12016 PyObject * obj0 = 0 ;
12017 char *kwnames[] = {
12018 (char *) "self", NULL
12019 };
12020
12021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12023 if (SWIG_arg_fail(1)) SWIG_fail;
12024 {
12025 PyThreadState* __tstate = wxPyBeginAllowThreads();
12026 result = (int)(arg1)->GetXMin();
12027
12028 wxPyEndAllowThreads(__tstate);
12029 if (PyErr_Occurred()) SWIG_fail;
12030 }
12031 {
12032 resultobj = SWIG_From_int((int)(result));
12033 }
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj;
12042 wxJoystick *arg1 = (wxJoystick *) 0 ;
12043 int result;
12044 PyObject * obj0 = 0 ;
12045 char *kwnames[] = {
12046 (char *) "self", NULL
12047 };
12048
12049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12051 if (SWIG_arg_fail(1)) SWIG_fail;
12052 {
12053 PyThreadState* __tstate = wxPyBeginAllowThreads();
12054 result = (int)(arg1)->GetYMin();
12055
12056 wxPyEndAllowThreads(__tstate);
12057 if (PyErr_Occurred()) SWIG_fail;
12058 }
12059 {
12060 resultobj = SWIG_From_int((int)(result));
12061 }
12062 return resultobj;
12063 fail:
12064 return NULL;
12065 }
12066
12067
12068 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12069 PyObject *resultobj;
12070 wxJoystick *arg1 = (wxJoystick *) 0 ;
12071 int result;
12072 PyObject * obj0 = 0 ;
12073 char *kwnames[] = {
12074 (char *) "self", NULL
12075 };
12076
12077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12079 if (SWIG_arg_fail(1)) SWIG_fail;
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (int)(arg1)->GetZMin();
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 resultobj = SWIG_From_int((int)(result));
12089 }
12090 return resultobj;
12091 fail:
12092 return NULL;
12093 }
12094
12095
12096 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12097 PyObject *resultobj;
12098 wxJoystick *arg1 = (wxJoystick *) 0 ;
12099 int result;
12100 PyObject * obj0 = 0 ;
12101 char *kwnames[] = {
12102 (char *) "self", NULL
12103 };
12104
12105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12107 if (SWIG_arg_fail(1)) SWIG_fail;
12108 {
12109 PyThreadState* __tstate = wxPyBeginAllowThreads();
12110 result = (int)(arg1)->GetXMax();
12111
12112 wxPyEndAllowThreads(__tstate);
12113 if (PyErr_Occurred()) SWIG_fail;
12114 }
12115 {
12116 resultobj = SWIG_From_int((int)(result));
12117 }
12118 return resultobj;
12119 fail:
12120 return NULL;
12121 }
12122
12123
12124 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12125 PyObject *resultobj;
12126 wxJoystick *arg1 = (wxJoystick *) 0 ;
12127 int result;
12128 PyObject * obj0 = 0 ;
12129 char *kwnames[] = {
12130 (char *) "self", NULL
12131 };
12132
12133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12135 if (SWIG_arg_fail(1)) SWIG_fail;
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (int)(arg1)->GetYMax();
12139
12140 wxPyEndAllowThreads(__tstate);
12141 if (PyErr_Occurred()) SWIG_fail;
12142 }
12143 {
12144 resultobj = SWIG_From_int((int)(result));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj;
12154 wxJoystick *arg1 = (wxJoystick *) 0 ;
12155 int result;
12156 PyObject * obj0 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 PyThreadState* __tstate = wxPyBeginAllowThreads();
12166 result = (int)(arg1)->GetZMax();
12167
12168 wxPyEndAllowThreads(__tstate);
12169 if (PyErr_Occurred()) SWIG_fail;
12170 }
12171 {
12172 resultobj = SWIG_From_int((int)(result));
12173 }
12174 return resultobj;
12175 fail:
12176 return NULL;
12177 }
12178
12179
12180 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12181 PyObject *resultobj;
12182 wxJoystick *arg1 = (wxJoystick *) 0 ;
12183 int result;
12184 PyObject * obj0 = 0 ;
12185 char *kwnames[] = {
12186 (char *) "self", NULL
12187 };
12188
12189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12191 if (SWIG_arg_fail(1)) SWIG_fail;
12192 {
12193 PyThreadState* __tstate = wxPyBeginAllowThreads();
12194 result = (int)(arg1)->GetNumberButtons();
12195
12196 wxPyEndAllowThreads(__tstate);
12197 if (PyErr_Occurred()) SWIG_fail;
12198 }
12199 {
12200 resultobj = SWIG_From_int((int)(result));
12201 }
12202 return resultobj;
12203 fail:
12204 return NULL;
12205 }
12206
12207
12208 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12209 PyObject *resultobj;
12210 wxJoystick *arg1 = (wxJoystick *) 0 ;
12211 int result;
12212 PyObject * obj0 = 0 ;
12213 char *kwnames[] = {
12214 (char *) "self", NULL
12215 };
12216
12217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12219 if (SWIG_arg_fail(1)) SWIG_fail;
12220 {
12221 PyThreadState* __tstate = wxPyBeginAllowThreads();
12222 result = (int)(arg1)->GetNumberAxes();
12223
12224 wxPyEndAllowThreads(__tstate);
12225 if (PyErr_Occurred()) SWIG_fail;
12226 }
12227 {
12228 resultobj = SWIG_From_int((int)(result));
12229 }
12230 return resultobj;
12231 fail:
12232 return NULL;
12233 }
12234
12235
12236 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12237 PyObject *resultobj;
12238 wxJoystick *arg1 = (wxJoystick *) 0 ;
12239 int result;
12240 PyObject * obj0 = 0 ;
12241 char *kwnames[] = {
12242 (char *) "self", NULL
12243 };
12244
12245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12247 if (SWIG_arg_fail(1)) SWIG_fail;
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (int)(arg1)->GetMaxButtons();
12251
12252 wxPyEndAllowThreads(__tstate);
12253 if (PyErr_Occurred()) SWIG_fail;
12254 }
12255 {
12256 resultobj = SWIG_From_int((int)(result));
12257 }
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj;
12266 wxJoystick *arg1 = (wxJoystick *) 0 ;
12267 int result;
12268 PyObject * obj0 = 0 ;
12269 char *kwnames[] = {
12270 (char *) "self", NULL
12271 };
12272
12273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12275 if (SWIG_arg_fail(1)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (int)(arg1)->GetMaxAxes();
12279
12280 wxPyEndAllowThreads(__tstate);
12281 if (PyErr_Occurred()) SWIG_fail;
12282 }
12283 {
12284 resultobj = SWIG_From_int((int)(result));
12285 }
12286 return resultobj;
12287 fail:
12288 return NULL;
12289 }
12290
12291
12292 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12293 PyObject *resultobj;
12294 wxJoystick *arg1 = (wxJoystick *) 0 ;
12295 int result;
12296 PyObject * obj0 = 0 ;
12297 char *kwnames[] = {
12298 (char *) "self", NULL
12299 };
12300
12301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12303 if (SWIG_arg_fail(1)) SWIG_fail;
12304 {
12305 PyThreadState* __tstate = wxPyBeginAllowThreads();
12306 result = (int)(arg1)->GetPollingMin();
12307
12308 wxPyEndAllowThreads(__tstate);
12309 if (PyErr_Occurred()) SWIG_fail;
12310 }
12311 {
12312 resultobj = SWIG_From_int((int)(result));
12313 }
12314 return resultobj;
12315 fail:
12316 return NULL;
12317 }
12318
12319
12320 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12321 PyObject *resultobj;
12322 wxJoystick *arg1 = (wxJoystick *) 0 ;
12323 int result;
12324 PyObject * obj0 = 0 ;
12325 char *kwnames[] = {
12326 (char *) "self", NULL
12327 };
12328
12329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12331 if (SWIG_arg_fail(1)) SWIG_fail;
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 result = (int)(arg1)->GetPollingMax();
12335
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 {
12340 resultobj = SWIG_From_int((int)(result));
12341 }
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj;
12350 wxJoystick *arg1 = (wxJoystick *) 0 ;
12351 int result;
12352 PyObject * obj0 = 0 ;
12353 char *kwnames[] = {
12354 (char *) "self", NULL
12355 };
12356
12357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12359 if (SWIG_arg_fail(1)) SWIG_fail;
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)(arg1)->GetRudderMin();
12363
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 {
12368 resultobj = SWIG_From_int((int)(result));
12369 }
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12377 PyObject *resultobj;
12378 wxJoystick *arg1 = (wxJoystick *) 0 ;
12379 int result;
12380 PyObject * obj0 = 0 ;
12381 char *kwnames[] = {
12382 (char *) "self", NULL
12383 };
12384
12385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12387 if (SWIG_arg_fail(1)) SWIG_fail;
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (int)(arg1)->GetRudderMax();
12391
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 {
12396 resultobj = SWIG_From_int((int)(result));
12397 }
12398 return resultobj;
12399 fail:
12400 return NULL;
12401 }
12402
12403
12404 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12405 PyObject *resultobj;
12406 wxJoystick *arg1 = (wxJoystick *) 0 ;
12407 int result;
12408 PyObject * obj0 = 0 ;
12409 char *kwnames[] = {
12410 (char *) "self", NULL
12411 };
12412
12413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12415 if (SWIG_arg_fail(1)) SWIG_fail;
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (int)(arg1)->GetUMin();
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 resultobj = SWIG_From_int((int)(result));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj;
12434 wxJoystick *arg1 = (wxJoystick *) 0 ;
12435 int result;
12436 PyObject * obj0 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "self", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12443 if (SWIG_arg_fail(1)) SWIG_fail;
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (int)(arg1)->GetUMax();
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 resultobj = SWIG_From_int((int)(result));
12453 }
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12461 PyObject *resultobj;
12462 wxJoystick *arg1 = (wxJoystick *) 0 ;
12463 int result;
12464 PyObject * obj0 = 0 ;
12465 char *kwnames[] = {
12466 (char *) "self", NULL
12467 };
12468
12469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12471 if (SWIG_arg_fail(1)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (int)(arg1)->GetVMin();
12475
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = SWIG_From_int((int)(result));
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12489 PyObject *resultobj;
12490 wxJoystick *arg1 = (wxJoystick *) 0 ;
12491 int result;
12492 PyObject * obj0 = 0 ;
12493 char *kwnames[] = {
12494 (char *) "self", NULL
12495 };
12496
12497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12499 if (SWIG_arg_fail(1)) SWIG_fail;
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (int)(arg1)->GetVMax();
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 resultobj = SWIG_From_int((int)(result));
12509 }
12510 return resultobj;
12511 fail:
12512 return NULL;
12513 }
12514
12515
12516 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12517 PyObject *resultobj;
12518 wxJoystick *arg1 = (wxJoystick *) 0 ;
12519 bool result;
12520 PyObject * obj0 = 0 ;
12521 char *kwnames[] = {
12522 (char *) "self", NULL
12523 };
12524
12525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12527 if (SWIG_arg_fail(1)) SWIG_fail;
12528 {
12529 PyThreadState* __tstate = wxPyBeginAllowThreads();
12530 result = (bool)(arg1)->HasRudder();
12531
12532 wxPyEndAllowThreads(__tstate);
12533 if (PyErr_Occurred()) SWIG_fail;
12534 }
12535 {
12536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12537 }
12538 return resultobj;
12539 fail:
12540 return NULL;
12541 }
12542
12543
12544 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12545 PyObject *resultobj;
12546 wxJoystick *arg1 = (wxJoystick *) 0 ;
12547 bool result;
12548 PyObject * obj0 = 0 ;
12549 char *kwnames[] = {
12550 (char *) "self", NULL
12551 };
12552
12553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12555 if (SWIG_arg_fail(1)) SWIG_fail;
12556 {
12557 PyThreadState* __tstate = wxPyBeginAllowThreads();
12558 result = (bool)(arg1)->HasZ();
12559
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 {
12564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12565 }
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12573 PyObject *resultobj;
12574 wxJoystick *arg1 = (wxJoystick *) 0 ;
12575 bool result;
12576 PyObject * obj0 = 0 ;
12577 char *kwnames[] = {
12578 (char *) "self", NULL
12579 };
12580
12581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12583 if (SWIG_arg_fail(1)) SWIG_fail;
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (bool)(arg1)->HasU();
12587
12588 wxPyEndAllowThreads(__tstate);
12589 if (PyErr_Occurred()) SWIG_fail;
12590 }
12591 {
12592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12593 }
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12601 PyObject *resultobj;
12602 wxJoystick *arg1 = (wxJoystick *) 0 ;
12603 bool result;
12604 PyObject * obj0 = 0 ;
12605 char *kwnames[] = {
12606 (char *) "self", NULL
12607 };
12608
12609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12611 if (SWIG_arg_fail(1)) SWIG_fail;
12612 {
12613 PyThreadState* __tstate = wxPyBeginAllowThreads();
12614 result = (bool)(arg1)->HasV();
12615
12616 wxPyEndAllowThreads(__tstate);
12617 if (PyErr_Occurred()) SWIG_fail;
12618 }
12619 {
12620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12621 }
12622 return resultobj;
12623 fail:
12624 return NULL;
12625 }
12626
12627
12628 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj;
12630 wxJoystick *arg1 = (wxJoystick *) 0 ;
12631 bool result;
12632 PyObject * obj0 = 0 ;
12633 char *kwnames[] = {
12634 (char *) "self", NULL
12635 };
12636
12637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12639 if (SWIG_arg_fail(1)) SWIG_fail;
12640 {
12641 PyThreadState* __tstate = wxPyBeginAllowThreads();
12642 result = (bool)(arg1)->HasPOV();
12643
12644 wxPyEndAllowThreads(__tstate);
12645 if (PyErr_Occurred()) SWIG_fail;
12646 }
12647 {
12648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12649 }
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12657 PyObject *resultobj;
12658 wxJoystick *arg1 = (wxJoystick *) 0 ;
12659 bool result;
12660 PyObject * obj0 = 0 ;
12661 char *kwnames[] = {
12662 (char *) "self", NULL
12663 };
12664
12665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12667 if (SWIG_arg_fail(1)) SWIG_fail;
12668 {
12669 PyThreadState* __tstate = wxPyBeginAllowThreads();
12670 result = (bool)(arg1)->HasPOV4Dir();
12671
12672 wxPyEndAllowThreads(__tstate);
12673 if (PyErr_Occurred()) SWIG_fail;
12674 }
12675 {
12676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12677 }
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12685 PyObject *resultobj;
12686 wxJoystick *arg1 = (wxJoystick *) 0 ;
12687 bool result;
12688 PyObject * obj0 = 0 ;
12689 char *kwnames[] = {
12690 (char *) "self", NULL
12691 };
12692
12693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12695 if (SWIG_arg_fail(1)) SWIG_fail;
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 result = (bool)(arg1)->HasPOVCTS();
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxJoystick *arg1 = (wxJoystick *) 0 ;
12715 wxWindow *arg2 = (wxWindow *) 0 ;
12716 int arg3 = (int) 0 ;
12717 bool result;
12718 PyObject * obj0 = 0 ;
12719 PyObject * obj1 = 0 ;
12720 PyObject * obj2 = 0 ;
12721 char *kwnames[] = {
12722 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12723 };
12724
12725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12727 if (SWIG_arg_fail(1)) SWIG_fail;
12728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12729 if (SWIG_arg_fail(2)) SWIG_fail;
12730 if (obj2) {
12731 {
12732 arg3 = (int)(SWIG_As_int(obj2));
12733 if (SWIG_arg_fail(3)) SWIG_fail;
12734 }
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 result = (bool)(arg1)->SetCapture(arg2,arg3);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 {
12744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12745 }
12746 return resultobj;
12747 fail:
12748 return NULL;
12749 }
12750
12751
12752 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12753 PyObject *resultobj;
12754 wxJoystick *arg1 = (wxJoystick *) 0 ;
12755 bool result;
12756 PyObject * obj0 = 0 ;
12757 char *kwnames[] = {
12758 (char *) "self", NULL
12759 };
12760
12761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12763 if (SWIG_arg_fail(1)) SWIG_fail;
12764 {
12765 PyThreadState* __tstate = wxPyBeginAllowThreads();
12766 result = (bool)(arg1)->ReleaseCapture();
12767
12768 wxPyEndAllowThreads(__tstate);
12769 if (PyErr_Occurred()) SWIG_fail;
12770 }
12771 {
12772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12773 }
12774 return resultobj;
12775 fail:
12776 return NULL;
12777 }
12778
12779
12780 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12781 PyObject *obj;
12782 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12783 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12784 Py_INCREF(obj);
12785 return Py_BuildValue((char *)"");
12786 }
12787 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12788 PyObject *resultobj;
12789 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12790 int arg2 = (int) 0 ;
12791 int arg3 = (int) wxJOYSTICK1 ;
12792 int arg4 = (int) 0 ;
12793 wxJoystickEvent *result;
12794 PyObject * obj0 = 0 ;
12795 PyObject * obj1 = 0 ;
12796 PyObject * obj2 = 0 ;
12797 PyObject * obj3 = 0 ;
12798 char *kwnames[] = {
12799 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12800 };
12801
12802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12803 if (obj0) {
12804 {
12805 arg1 = (wxEventType)(SWIG_As_int(obj0));
12806 if (SWIG_arg_fail(1)) SWIG_fail;
12807 }
12808 }
12809 if (obj1) {
12810 {
12811 arg2 = (int)(SWIG_As_int(obj1));
12812 if (SWIG_arg_fail(2)) SWIG_fail;
12813 }
12814 }
12815 if (obj2) {
12816 {
12817 arg3 = (int)(SWIG_As_int(obj2));
12818 if (SWIG_arg_fail(3)) SWIG_fail;
12819 }
12820 }
12821 if (obj3) {
12822 {
12823 arg4 = (int)(SWIG_As_int(obj3));
12824 if (SWIG_arg_fail(4)) SWIG_fail;
12825 }
12826 }
12827 {
12828 PyThreadState* __tstate = wxPyBeginAllowThreads();
12829 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12830
12831 wxPyEndAllowThreads(__tstate);
12832 if (PyErr_Occurred()) SWIG_fail;
12833 }
12834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12835 return resultobj;
12836 fail:
12837 return NULL;
12838 }
12839
12840
12841 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12842 PyObject *resultobj;
12843 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12844 wxPoint result;
12845 PyObject * obj0 = 0 ;
12846 char *kwnames[] = {
12847 (char *) "self", NULL
12848 };
12849
12850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12852 if (SWIG_arg_fail(1)) SWIG_fail;
12853 {
12854 PyThreadState* __tstate = wxPyBeginAllowThreads();
12855 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12856
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 wxPoint * resultptr;
12862 resultptr = new wxPoint((wxPoint &)(result));
12863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12864 }
12865 return resultobj;
12866 fail:
12867 return NULL;
12868 }
12869
12870
12871 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12872 PyObject *resultobj;
12873 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12874 int result;
12875 PyObject * obj0 = 0 ;
12876 char *kwnames[] = {
12877 (char *) "self", NULL
12878 };
12879
12880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12882 if (SWIG_arg_fail(1)) SWIG_fail;
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12886
12887 wxPyEndAllowThreads(__tstate);
12888 if (PyErr_Occurred()) SWIG_fail;
12889 }
12890 {
12891 resultobj = SWIG_From_int((int)(result));
12892 }
12893 return resultobj;
12894 fail:
12895 return NULL;
12896 }
12897
12898
12899 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12900 PyObject *resultobj;
12901 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12902 int result;
12903 PyObject * obj0 = 0 ;
12904 char *kwnames[] = {
12905 (char *) "self", NULL
12906 };
12907
12908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12910 if (SWIG_arg_fail(1)) SWIG_fail;
12911 {
12912 PyThreadState* __tstate = wxPyBeginAllowThreads();
12913 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12914
12915 wxPyEndAllowThreads(__tstate);
12916 if (PyErr_Occurred()) SWIG_fail;
12917 }
12918 {
12919 resultobj = SWIG_From_int((int)(result));
12920 }
12921 return resultobj;
12922 fail:
12923 return NULL;
12924 }
12925
12926
12927 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12928 PyObject *resultobj;
12929 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12930 int result;
12931 PyObject * obj0 = 0 ;
12932 char *kwnames[] = {
12933 (char *) "self", NULL
12934 };
12935
12936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12938 if (SWIG_arg_fail(1)) SWIG_fail;
12939 {
12940 PyThreadState* __tstate = wxPyBeginAllowThreads();
12941 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12942
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 resultobj = SWIG_From_int((int)(result));
12948 }
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12956 PyObject *resultobj;
12957 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12958 int result;
12959 PyObject * obj0 = 0 ;
12960 char *kwnames[] = {
12961 (char *) "self", NULL
12962 };
12963
12964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12966 if (SWIG_arg_fail(1)) SWIG_fail;
12967 {
12968 PyThreadState* __tstate = wxPyBeginAllowThreads();
12969 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12970
12971 wxPyEndAllowThreads(__tstate);
12972 if (PyErr_Occurred()) SWIG_fail;
12973 }
12974 {
12975 resultobj = SWIG_From_int((int)(result));
12976 }
12977 return resultobj;
12978 fail:
12979 return NULL;
12980 }
12981
12982
12983 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12984 PyObject *resultobj;
12985 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12986 int arg2 ;
12987 PyObject * obj0 = 0 ;
12988 PyObject * obj1 = 0 ;
12989 char *kwnames[] = {
12990 (char *) "self",(char *) "stick", NULL
12991 };
12992
12993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12995 if (SWIG_arg_fail(1)) SWIG_fail;
12996 {
12997 arg2 = (int)(SWIG_As_int(obj1));
12998 if (SWIG_arg_fail(2)) SWIG_fail;
12999 }
13000 {
13001 PyThreadState* __tstate = wxPyBeginAllowThreads();
13002 (arg1)->SetJoystick(arg2);
13003
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 Py_INCREF(Py_None); resultobj = Py_None;
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13015 PyObject *resultobj;
13016 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13017 int arg2 ;
13018 PyObject * obj0 = 0 ;
13019 PyObject * obj1 = 0 ;
13020 char *kwnames[] = {
13021 (char *) "self",(char *) "state", NULL
13022 };
13023
13024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13026 if (SWIG_arg_fail(1)) SWIG_fail;
13027 {
13028 arg2 = (int)(SWIG_As_int(obj1));
13029 if (SWIG_arg_fail(2)) SWIG_fail;
13030 }
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 (arg1)->SetButtonState(arg2);
13034
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 Py_INCREF(Py_None); resultobj = Py_None;
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13046 PyObject *resultobj;
13047 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13048 int arg2 ;
13049 PyObject * obj0 = 0 ;
13050 PyObject * obj1 = 0 ;
13051 char *kwnames[] = {
13052 (char *) "self",(char *) "change", NULL
13053 };
13054
13055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13057 if (SWIG_arg_fail(1)) SWIG_fail;
13058 {
13059 arg2 = (int)(SWIG_As_int(obj1));
13060 if (SWIG_arg_fail(2)) SWIG_fail;
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 (arg1)->SetButtonChange(arg2);
13065
13066 wxPyEndAllowThreads(__tstate);
13067 if (PyErr_Occurred()) SWIG_fail;
13068 }
13069 Py_INCREF(Py_None); resultobj = Py_None;
13070 return resultobj;
13071 fail:
13072 return NULL;
13073 }
13074
13075
13076 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13077 PyObject *resultobj;
13078 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13079 wxPoint *arg2 = 0 ;
13080 wxPoint temp2 ;
13081 PyObject * obj0 = 0 ;
13082 PyObject * obj1 = 0 ;
13083 char *kwnames[] = {
13084 (char *) "self",(char *) "pos", NULL
13085 };
13086
13087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13089 if (SWIG_arg_fail(1)) SWIG_fail;
13090 {
13091 arg2 = &temp2;
13092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13093 }
13094 {
13095 PyThreadState* __tstate = wxPyBeginAllowThreads();
13096 (arg1)->SetPosition((wxPoint const &)*arg2);
13097
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 Py_INCREF(Py_None); resultobj = Py_None;
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj;
13110 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13111 int arg2 ;
13112 PyObject * obj0 = 0 ;
13113 PyObject * obj1 = 0 ;
13114 char *kwnames[] = {
13115 (char *) "self",(char *) "zPos", NULL
13116 };
13117
13118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13120 if (SWIG_arg_fail(1)) SWIG_fail;
13121 {
13122 arg2 = (int)(SWIG_As_int(obj1));
13123 if (SWIG_arg_fail(2)) SWIG_fail;
13124 }
13125 {
13126 PyThreadState* __tstate = wxPyBeginAllowThreads();
13127 (arg1)->SetZPosition(arg2);
13128
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 Py_INCREF(Py_None); resultobj = Py_None;
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj;
13141 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13142 bool result;
13143 PyObject * obj0 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13160 }
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj;
13169 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13170 bool result;
13171 PyObject * obj0 = 0 ;
13172 char *kwnames[] = {
13173 (char *) "self", NULL
13174 };
13175
13176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13178 if (SWIG_arg_fail(1)) SWIG_fail;
13179 {
13180 PyThreadState* __tstate = wxPyBeginAllowThreads();
13181 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13182
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 {
13187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13188 }
13189 return resultobj;
13190 fail:
13191 return NULL;
13192 }
13193
13194
13195 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13196 PyObject *resultobj;
13197 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13198 bool result;
13199 PyObject * obj0 = 0 ;
13200 char *kwnames[] = {
13201 (char *) "self", NULL
13202 };
13203
13204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13206 if (SWIG_arg_fail(1)) SWIG_fail;
13207 {
13208 PyThreadState* __tstate = wxPyBeginAllowThreads();
13209 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13210
13211 wxPyEndAllowThreads(__tstate);
13212 if (PyErr_Occurred()) SWIG_fail;
13213 }
13214 {
13215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13216 }
13217 return resultobj;
13218 fail:
13219 return NULL;
13220 }
13221
13222
13223 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13224 PyObject *resultobj;
13225 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13226 int arg2 = (int) wxJOY_BUTTON_ANY ;
13227 bool result;
13228 PyObject * obj0 = 0 ;
13229 PyObject * obj1 = 0 ;
13230 char *kwnames[] = {
13231 (char *) "self",(char *) "but", NULL
13232 };
13233
13234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13236 if (SWIG_arg_fail(1)) SWIG_fail;
13237 if (obj1) {
13238 {
13239 arg2 = (int)(SWIG_As_int(obj1));
13240 if (SWIG_arg_fail(2)) SWIG_fail;
13241 }
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13246
13247 wxPyEndAllowThreads(__tstate);
13248 if (PyErr_Occurred()) SWIG_fail;
13249 }
13250 {
13251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13252 }
13253 return resultobj;
13254 fail:
13255 return NULL;
13256 }
13257
13258
13259 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13260 PyObject *resultobj;
13261 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13262 int arg2 = (int) wxJOY_BUTTON_ANY ;
13263 bool result;
13264 PyObject * obj0 = 0 ;
13265 PyObject * obj1 = 0 ;
13266 char *kwnames[] = {
13267 (char *) "self",(char *) "but", NULL
13268 };
13269
13270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13272 if (SWIG_arg_fail(1)) SWIG_fail;
13273 if (obj1) {
13274 {
13275 arg2 = (int)(SWIG_As_int(obj1));
13276 if (SWIG_arg_fail(2)) SWIG_fail;
13277 }
13278 }
13279 {
13280 PyThreadState* __tstate = wxPyBeginAllowThreads();
13281 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13282
13283 wxPyEndAllowThreads(__tstate);
13284 if (PyErr_Occurred()) SWIG_fail;
13285 }
13286 {
13287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13288 }
13289 return resultobj;
13290 fail:
13291 return NULL;
13292 }
13293
13294
13295 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13296 PyObject *resultobj;
13297 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13298 int arg2 = (int) wxJOY_BUTTON_ANY ;
13299 bool result;
13300 PyObject * obj0 = 0 ;
13301 PyObject * obj1 = 0 ;
13302 char *kwnames[] = {
13303 (char *) "self",(char *) "but", NULL
13304 };
13305
13306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13308 if (SWIG_arg_fail(1)) SWIG_fail;
13309 if (obj1) {
13310 {
13311 arg2 = (int)(SWIG_As_int(obj1));
13312 if (SWIG_arg_fail(2)) SWIG_fail;
13313 }
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13318
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 {
13323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13324 }
13325 return resultobj;
13326 fail:
13327 return NULL;
13328 }
13329
13330
13331 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13332 PyObject *obj;
13333 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13334 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13335 Py_INCREF(obj);
13336 return Py_BuildValue((char *)"");
13337 }
13338 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13339 PyObject *resultobj;
13340 wxString const &arg1_defvalue = wxPyEmptyString ;
13341 wxString *arg1 = (wxString *) &arg1_defvalue ;
13342 wxSound *result;
13343 bool temp1 = false ;
13344 PyObject * obj0 = 0 ;
13345 char *kwnames[] = {
13346 (char *) "fileName", NULL
13347 };
13348
13349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13350 if (obj0) {
13351 {
13352 arg1 = wxString_in_helper(obj0);
13353 if (arg1 == NULL) SWIG_fail;
13354 temp1 = true;
13355 }
13356 }
13357 {
13358 if (!wxPyCheckForApp()) SWIG_fail;
13359 PyThreadState* __tstate = wxPyBeginAllowThreads();
13360 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13361
13362 wxPyEndAllowThreads(__tstate);
13363 if (PyErr_Occurred()) SWIG_fail;
13364 }
13365 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13366 {
13367 if (temp1)
13368 delete arg1;
13369 }
13370 return resultobj;
13371 fail:
13372 {
13373 if (temp1)
13374 delete arg1;
13375 }
13376 return NULL;
13377 }
13378
13379
13380 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13381 PyObject *resultobj;
13382 PyObject *arg1 = (PyObject *) 0 ;
13383 wxSound *result;
13384 PyObject * obj0 = 0 ;
13385 char *kwnames[] = {
13386 (char *) "data", NULL
13387 };
13388
13389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13390 arg1 = obj0;
13391 {
13392 if (!wxPyCheckForApp()) SWIG_fail;
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxSound *)new_wxSound(arg1);
13395
13396 wxPyEndAllowThreads(__tstate);
13397 if (PyErr_Occurred()) SWIG_fail;
13398 }
13399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13400 return resultobj;
13401 fail:
13402 return NULL;
13403 }
13404
13405
13406 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13407 PyObject *resultobj;
13408 wxSound *arg1 = (wxSound *) 0 ;
13409 PyObject * obj0 = 0 ;
13410 char *kwnames[] = {
13411 (char *) "self", NULL
13412 };
13413
13414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13416 if (SWIG_arg_fail(1)) SWIG_fail;
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 delete arg1;
13420
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 Py_INCREF(Py_None); resultobj = Py_None;
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13432 PyObject *resultobj;
13433 wxSound *arg1 = (wxSound *) 0 ;
13434 wxString *arg2 = 0 ;
13435 bool result;
13436 bool temp2 = false ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 char *kwnames[] = {
13440 (char *) "self",(char *) "fileName", NULL
13441 };
13442
13443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13445 if (SWIG_arg_fail(1)) SWIG_fail;
13446 {
13447 arg2 = wxString_in_helper(obj1);
13448 if (arg2 == NULL) SWIG_fail;
13449 temp2 = true;
13450 }
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 result = (bool)(arg1)->Create((wxString const &)*arg2);
13454
13455 wxPyEndAllowThreads(__tstate);
13456 if (PyErr_Occurred()) SWIG_fail;
13457 }
13458 {
13459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13460 }
13461 {
13462 if (temp2)
13463 delete arg2;
13464 }
13465 return resultobj;
13466 fail:
13467 {
13468 if (temp2)
13469 delete arg2;
13470 }
13471 return NULL;
13472 }
13473
13474
13475 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13476 PyObject *resultobj;
13477 wxSound *arg1 = (wxSound *) 0 ;
13478 PyObject *arg2 = (PyObject *) 0 ;
13479 bool result;
13480 PyObject * obj0 = 0 ;
13481 PyObject * obj1 = 0 ;
13482 char *kwnames[] = {
13483 (char *) "self",(char *) "data", NULL
13484 };
13485
13486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13488 if (SWIG_arg_fail(1)) SWIG_fail;
13489 arg2 = obj1;
13490 {
13491 PyThreadState* __tstate = wxPyBeginAllowThreads();
13492 result = (bool)wxSound_CreateFromData(arg1,arg2);
13493
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 return resultobj;
13501 fail:
13502 return NULL;
13503 }
13504
13505
13506 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13507 PyObject *resultobj;
13508 wxSound *arg1 = (wxSound *) 0 ;
13509 bool result;
13510 PyObject * obj0 = 0 ;
13511 char *kwnames[] = {
13512 (char *) "self", NULL
13513 };
13514
13515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13517 if (SWIG_arg_fail(1)) SWIG_fail;
13518 {
13519 PyThreadState* __tstate = wxPyBeginAllowThreads();
13520 result = (bool)(arg1)->IsOk();
13521
13522 wxPyEndAllowThreads(__tstate);
13523 if (PyErr_Occurred()) SWIG_fail;
13524 }
13525 {
13526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13527 }
13528 return resultobj;
13529 fail:
13530 return NULL;
13531 }
13532
13533
13534 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13535 PyObject *resultobj;
13536 wxSound *arg1 = (wxSound *) 0 ;
13537 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13538 bool result;
13539 PyObject * obj0 = 0 ;
13540 PyObject * obj1 = 0 ;
13541 char *kwnames[] = {
13542 (char *) "self",(char *) "flags", NULL
13543 };
13544
13545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13547 if (SWIG_arg_fail(1)) SWIG_fail;
13548 if (obj1) {
13549 {
13550 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13551 if (SWIG_arg_fail(2)) SWIG_fail;
13552 }
13553 }
13554 {
13555 if (!wxPyCheckForApp()) SWIG_fail;
13556 PyThreadState* __tstate = wxPyBeginAllowThreads();
13557 result = (bool)((wxSound const *)arg1)->Play(arg2);
13558
13559 wxPyEndAllowThreads(__tstate);
13560 if (PyErr_Occurred()) SWIG_fail;
13561 }
13562 {
13563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13564 }
13565 return resultobj;
13566 fail:
13567 return NULL;
13568 }
13569
13570
13571 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13572 PyObject *resultobj;
13573 wxString *arg1 = 0 ;
13574 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13575 bool result;
13576 bool temp1 = false ;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "filename",(char *) "flags", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13584 {
13585 arg1 = wxString_in_helper(obj0);
13586 if (arg1 == NULL) SWIG_fail;
13587 temp1 = true;
13588 }
13589 if (obj1) {
13590 {
13591 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13592 if (SWIG_arg_fail(2)) SWIG_fail;
13593 }
13594 }
13595 {
13596 if (!wxPyCheckForApp()) SWIG_fail;
13597 PyThreadState* __tstate = wxPyBeginAllowThreads();
13598 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13599
13600 wxPyEndAllowThreads(__tstate);
13601 if (PyErr_Occurred()) SWIG_fail;
13602 }
13603 {
13604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13605 }
13606 {
13607 if (temp1)
13608 delete arg1;
13609 }
13610 return resultobj;
13611 fail:
13612 {
13613 if (temp1)
13614 delete arg1;
13615 }
13616 return NULL;
13617 }
13618
13619
13620 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13621 PyObject *resultobj;
13622 char *kwnames[] = {
13623 NULL
13624 };
13625
13626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13627 {
13628 if (!wxPyCheckForApp()) SWIG_fail;
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 wxSound::Stop();
13631
13632 wxPyEndAllowThreads(__tstate);
13633 if (PyErr_Occurred()) SWIG_fail;
13634 }
13635 Py_INCREF(Py_None); resultobj = Py_None;
13636 return resultobj;
13637 fail:
13638 return NULL;
13639 }
13640
13641
13642 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13643 PyObject *obj;
13644 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13645 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13646 Py_INCREF(obj);
13647 return Py_BuildValue((char *)"");
13648 }
13649 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj;
13651 wxString *arg1 = 0 ;
13652 wxString *arg2 = 0 ;
13653 wxString *arg3 = 0 ;
13654 wxString *arg4 = 0 ;
13655 wxFileTypeInfo *result;
13656 bool temp1 = false ;
13657 bool temp2 = false ;
13658 bool temp3 = false ;
13659 bool temp4 = false ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 PyObject * obj3 = 0 ;
13664 char *kwnames[] = {
13665 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13666 };
13667
13668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13669 {
13670 arg1 = wxString_in_helper(obj0);
13671 if (arg1 == NULL) SWIG_fail;
13672 temp1 = true;
13673 }
13674 {
13675 arg2 = wxString_in_helper(obj1);
13676 if (arg2 == NULL) SWIG_fail;
13677 temp2 = true;
13678 }
13679 {
13680 arg3 = wxString_in_helper(obj2);
13681 if (arg3 == NULL) SWIG_fail;
13682 temp3 = true;
13683 }
13684 {
13685 arg4 = wxString_in_helper(obj3);
13686 if (arg4 == NULL) SWIG_fail;
13687 temp4 = true;
13688 }
13689 {
13690 PyThreadState* __tstate = wxPyBeginAllowThreads();
13691 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13692
13693 wxPyEndAllowThreads(__tstate);
13694 if (PyErr_Occurred()) SWIG_fail;
13695 }
13696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13697 {
13698 if (temp1)
13699 delete arg1;
13700 }
13701 {
13702 if (temp2)
13703 delete arg2;
13704 }
13705 {
13706 if (temp3)
13707 delete arg3;
13708 }
13709 {
13710 if (temp4)
13711 delete arg4;
13712 }
13713 return resultobj;
13714 fail:
13715 {
13716 if (temp1)
13717 delete arg1;
13718 }
13719 {
13720 if (temp2)
13721 delete arg2;
13722 }
13723 {
13724 if (temp3)
13725 delete arg3;
13726 }
13727 {
13728 if (temp4)
13729 delete arg4;
13730 }
13731 return NULL;
13732 }
13733
13734
13735 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13736 PyObject *resultobj;
13737 wxArrayString *arg1 = 0 ;
13738 wxFileTypeInfo *result;
13739 bool temp1 = false ;
13740 PyObject * obj0 = 0 ;
13741 char *kwnames[] = {
13742 (char *) "sArray", NULL
13743 };
13744
13745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13746 {
13747 if (! PySequence_Check(obj0)) {
13748 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13749 SWIG_fail;
13750 }
13751 arg1 = new wxArrayString;
13752 temp1 = true;
13753 int i, len=PySequence_Length(obj0);
13754 for (i=0; i<len; i++) {
13755 PyObject* item = PySequence_GetItem(obj0, i);
13756 #if wxUSE_UNICODE
13757 PyObject* str = PyObject_Unicode(item);
13758 #else
13759 PyObject* str = PyObject_Str(item);
13760 #endif
13761 if (PyErr_Occurred()) SWIG_fail;
13762 arg1->Add(Py2wxString(str));
13763 Py_DECREF(item);
13764 Py_DECREF(str);
13765 }
13766 }
13767 {
13768 PyThreadState* __tstate = wxPyBeginAllowThreads();
13769 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13770
13771 wxPyEndAllowThreads(__tstate);
13772 if (PyErr_Occurred()) SWIG_fail;
13773 }
13774 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13775 {
13776 if (temp1) delete arg1;
13777 }
13778 return resultobj;
13779 fail:
13780 {
13781 if (temp1) delete arg1;
13782 }
13783 return NULL;
13784 }
13785
13786
13787 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13788 PyObject *resultobj;
13789 wxFileTypeInfo *result;
13790 char *kwnames[] = {
13791 NULL
13792 };
13793
13794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13795 {
13796 PyThreadState* __tstate = wxPyBeginAllowThreads();
13797 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13798
13799 wxPyEndAllowThreads(__tstate);
13800 if (PyErr_Occurred()) SWIG_fail;
13801 }
13802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13803 return resultobj;
13804 fail:
13805 return NULL;
13806 }
13807
13808
13809 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13810 PyObject *resultobj;
13811 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13812 bool result;
13813 PyObject * obj0 = 0 ;
13814 char *kwnames[] = {
13815 (char *) "self", NULL
13816 };
13817
13818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13820 if (SWIG_arg_fail(1)) SWIG_fail;
13821 {
13822 PyThreadState* __tstate = wxPyBeginAllowThreads();
13823 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13824
13825 wxPyEndAllowThreads(__tstate);
13826 if (PyErr_Occurred()) SWIG_fail;
13827 }
13828 {
13829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13830 }
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj;
13839 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13840 wxString *arg2 = 0 ;
13841 int arg3 = (int) 0 ;
13842 bool temp2 = false ;
13843 PyObject * obj0 = 0 ;
13844 PyObject * obj1 = 0 ;
13845 PyObject * obj2 = 0 ;
13846 char *kwnames[] = {
13847 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13848 };
13849
13850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13852 if (SWIG_arg_fail(1)) SWIG_fail;
13853 {
13854 arg2 = wxString_in_helper(obj1);
13855 if (arg2 == NULL) SWIG_fail;
13856 temp2 = true;
13857 }
13858 if (obj2) {
13859 {
13860 arg3 = (int)(SWIG_As_int(obj2));
13861 if (SWIG_arg_fail(3)) SWIG_fail;
13862 }
13863 }
13864 {
13865 PyThreadState* __tstate = wxPyBeginAllowThreads();
13866 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13867
13868 wxPyEndAllowThreads(__tstate);
13869 if (PyErr_Occurred()) SWIG_fail;
13870 }
13871 Py_INCREF(Py_None); resultobj = Py_None;
13872 {
13873 if (temp2)
13874 delete arg2;
13875 }
13876 return resultobj;
13877 fail:
13878 {
13879 if (temp2)
13880 delete arg2;
13881 }
13882 return NULL;
13883 }
13884
13885
13886 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj;
13888 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13889 wxString *arg2 = 0 ;
13890 bool temp2 = false ;
13891 PyObject * obj0 = 0 ;
13892 PyObject * obj1 = 0 ;
13893 char *kwnames[] = {
13894 (char *) "self",(char *) "shortDesc", NULL
13895 };
13896
13897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13899 if (SWIG_arg_fail(1)) SWIG_fail;
13900 {
13901 arg2 = wxString_in_helper(obj1);
13902 if (arg2 == NULL) SWIG_fail;
13903 temp2 = true;
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 (arg1)->SetShortDesc((wxString const &)*arg2);
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 Py_INCREF(Py_None); resultobj = Py_None;
13913 {
13914 if (temp2)
13915 delete arg2;
13916 }
13917 return resultobj;
13918 fail:
13919 {
13920 if (temp2)
13921 delete arg2;
13922 }
13923 return NULL;
13924 }
13925
13926
13927 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13928 PyObject *resultobj;
13929 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13930 wxString *result;
13931 PyObject * obj0 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "self", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13938 if (SWIG_arg_fail(1)) SWIG_fail;
13939 {
13940 PyThreadState* __tstate = wxPyBeginAllowThreads();
13941 {
13942 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13943 result = (wxString *) &_result_ref;
13944 }
13945
13946 wxPyEndAllowThreads(__tstate);
13947 if (PyErr_Occurred()) SWIG_fail;
13948 }
13949 {
13950 #if wxUSE_UNICODE
13951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13952 #else
13953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13954 #endif
13955 }
13956 return resultobj;
13957 fail:
13958 return NULL;
13959 }
13960
13961
13962 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj;
13964 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13965 wxString *result;
13966 PyObject * obj0 = 0 ;
13967 char *kwnames[] = {
13968 (char *) "self", NULL
13969 };
13970
13971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13973 if (SWIG_arg_fail(1)) SWIG_fail;
13974 {
13975 PyThreadState* __tstate = wxPyBeginAllowThreads();
13976 {
13977 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13978 result = (wxString *) &_result_ref;
13979 }
13980
13981 wxPyEndAllowThreads(__tstate);
13982 if (PyErr_Occurred()) SWIG_fail;
13983 }
13984 {
13985 #if wxUSE_UNICODE
13986 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13987 #else
13988 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13989 #endif
13990 }
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj;
13999 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14000 wxString *result;
14001 PyObject * obj0 = 0 ;
14002 char *kwnames[] = {
14003 (char *) "self", NULL
14004 };
14005
14006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
14007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14008 if (SWIG_arg_fail(1)) SWIG_fail;
14009 {
14010 PyThreadState* __tstate = wxPyBeginAllowThreads();
14011 {
14012 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14013 result = (wxString *) &_result_ref;
14014 }
14015
14016 wxPyEndAllowThreads(__tstate);
14017 if (PyErr_Occurred()) SWIG_fail;
14018 }
14019 {
14020 #if wxUSE_UNICODE
14021 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14022 #else
14023 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14024 #endif
14025 }
14026 return resultobj;
14027 fail:
14028 return NULL;
14029 }
14030
14031
14032 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14033 PyObject *resultobj;
14034 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14035 wxString *result;
14036 PyObject * obj0 = 0 ;
14037 char *kwnames[] = {
14038 (char *) "self", NULL
14039 };
14040
14041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14043 if (SWIG_arg_fail(1)) SWIG_fail;
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 {
14047 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14048 result = (wxString *) &_result_ref;
14049 }
14050
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 {
14055 #if wxUSE_UNICODE
14056 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14057 #else
14058 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14059 #endif
14060 }
14061 return resultobj;
14062 fail:
14063 return NULL;
14064 }
14065
14066
14067 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14068 PyObject *resultobj;
14069 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14070 wxString *result;
14071 PyObject * obj0 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "self", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 {
14080 PyThreadState* __tstate = wxPyBeginAllowThreads();
14081 {
14082 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14083 result = (wxString *) &_result_ref;
14084 }
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 {
14090 #if wxUSE_UNICODE
14091 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14092 #else
14093 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14094 #endif
14095 }
14096 return resultobj;
14097 fail:
14098 return NULL;
14099 }
14100
14101
14102 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14103 PyObject *resultobj;
14104 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14105 wxArrayString *result;
14106 PyObject * obj0 = 0 ;
14107 char *kwnames[] = {
14108 (char *) "self", NULL
14109 };
14110
14111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14113 if (SWIG_arg_fail(1)) SWIG_fail;
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 {
14117 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14118 result = (wxArrayString *) &_result_ref;
14119 }
14120
14121 wxPyEndAllowThreads(__tstate);
14122 if (PyErr_Occurred()) SWIG_fail;
14123 }
14124 {
14125 resultobj = wxArrayString2PyList_helper(*result);
14126 }
14127 return resultobj;
14128 fail:
14129 return NULL;
14130 }
14131
14132
14133 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14134 PyObject *resultobj;
14135 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14136 int result;
14137 PyObject * obj0 = 0 ;
14138 char *kwnames[] = {
14139 (char *) "self", NULL
14140 };
14141
14142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14144 if (SWIG_arg_fail(1)) SWIG_fail;
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 {
14153 resultobj = SWIG_From_int((int)(result));
14154 }
14155 return resultobj;
14156 fail:
14157 return NULL;
14158 }
14159
14160
14161 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14162 PyObject *resultobj;
14163 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14164 wxString *result;
14165 PyObject * obj0 = 0 ;
14166 char *kwnames[] = {
14167 (char *) "self", NULL
14168 };
14169
14170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14172 if (SWIG_arg_fail(1)) SWIG_fail;
14173 {
14174 PyThreadState* __tstate = wxPyBeginAllowThreads();
14175 {
14176 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14177 result = (wxString *) &_result_ref;
14178 }
14179
14180 wxPyEndAllowThreads(__tstate);
14181 if (PyErr_Occurred()) SWIG_fail;
14182 }
14183 {
14184 #if wxUSE_UNICODE
14185 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14186 #else
14187 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14188 #endif
14189 }
14190 return resultobj;
14191 fail:
14192 return NULL;
14193 }
14194
14195
14196 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14197 PyObject *resultobj;
14198 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14199 int result;
14200 PyObject * obj0 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 {
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 resultobj = SWIG_From_int((int)(result));
14217 }
14218 return resultobj;
14219 fail:
14220 return NULL;
14221 }
14222
14223
14224 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14225 PyObject *obj;
14226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14227 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14228 Py_INCREF(obj);
14229 return Py_BuildValue((char *)"");
14230 }
14231 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14232 PyObject *resultobj;
14233 wxFileTypeInfo *arg1 = 0 ;
14234 wxFileType *result;
14235 PyObject * obj0 = 0 ;
14236 char *kwnames[] = {
14237 (char *) "ftInfo", NULL
14238 };
14239
14240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14241 {
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 if (arg1 == NULL) {
14245 SWIG_null_ref("wxFileTypeInfo");
14246 }
14247 if (SWIG_arg_fail(1)) SWIG_fail;
14248 }
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14252
14253 wxPyEndAllowThreads(__tstate);
14254 if (PyErr_Occurred()) SWIG_fail;
14255 }
14256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14257 return resultobj;
14258 fail:
14259 return NULL;
14260 }
14261
14262
14263 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14264 PyObject *resultobj;
14265 wxFileType *arg1 = (wxFileType *) 0 ;
14266 PyObject * obj0 = 0 ;
14267 char *kwnames[] = {
14268 (char *) "self", NULL
14269 };
14270
14271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14273 if (SWIG_arg_fail(1)) SWIG_fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 delete arg1;
14277
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 Py_INCREF(Py_None); resultobj = Py_None;
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14289 PyObject *resultobj;
14290 wxFileType *arg1 = (wxFileType *) 0 ;
14291 PyObject *result;
14292 PyObject * obj0 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (PyObject *)wxFileType_GetMimeType(arg1);
14303
14304 wxPyEndAllowThreads(__tstate);
14305 if (PyErr_Occurred()) SWIG_fail;
14306 }
14307 resultobj = result;
14308 return resultobj;
14309 fail:
14310 return NULL;
14311 }
14312
14313
14314 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14315 PyObject *resultobj;
14316 wxFileType *arg1 = (wxFileType *) 0 ;
14317 PyObject *result;
14318 PyObject * obj0 = 0 ;
14319 char *kwnames[] = {
14320 (char *) "self", NULL
14321 };
14322
14323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14325 if (SWIG_arg_fail(1)) SWIG_fail;
14326 {
14327 PyThreadState* __tstate = wxPyBeginAllowThreads();
14328 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14329
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 resultobj = result;
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxFileType *arg1 = (wxFileType *) 0 ;
14343 PyObject *result;
14344 PyObject * obj0 = 0 ;
14345 char *kwnames[] = {
14346 (char *) "self", NULL
14347 };
14348
14349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14351 if (SWIG_arg_fail(1)) SWIG_fail;
14352 {
14353 PyThreadState* __tstate = wxPyBeginAllowThreads();
14354 result = (PyObject *)wxFileType_GetExtensions(arg1);
14355
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 resultobj = result;
14360 return resultobj;
14361 fail:
14362 return NULL;
14363 }
14364
14365
14366 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj;
14368 wxFileType *arg1 = (wxFileType *) 0 ;
14369 wxIcon *result;
14370 PyObject * obj0 = 0 ;
14371 char *kwnames[] = {
14372 (char *) "self", NULL
14373 };
14374
14375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14377 if (SWIG_arg_fail(1)) SWIG_fail;
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (wxIcon *)wxFileType_GetIcon(arg1);
14381
14382 wxPyEndAllowThreads(__tstate);
14383 if (PyErr_Occurred()) SWIG_fail;
14384 }
14385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14386 return resultobj;
14387 fail:
14388 return NULL;
14389 }
14390
14391
14392 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14393 PyObject *resultobj;
14394 wxFileType *arg1 = (wxFileType *) 0 ;
14395 PyObject *result;
14396 PyObject * obj0 = 0 ;
14397 char *kwnames[] = {
14398 (char *) "self", NULL
14399 };
14400
14401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14403 if (SWIG_arg_fail(1)) SWIG_fail;
14404 {
14405 PyThreadState* __tstate = wxPyBeginAllowThreads();
14406 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14407
14408 wxPyEndAllowThreads(__tstate);
14409 if (PyErr_Occurred()) SWIG_fail;
14410 }
14411 resultobj = result;
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14419 PyObject *resultobj;
14420 wxFileType *arg1 = (wxFileType *) 0 ;
14421 PyObject *result;
14422 PyObject * obj0 = 0 ;
14423 char *kwnames[] = {
14424 (char *) "self", NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14429 if (SWIG_arg_fail(1)) SWIG_fail;
14430 {
14431 PyThreadState* __tstate = wxPyBeginAllowThreads();
14432 result = (PyObject *)wxFileType_GetDescription(arg1);
14433
14434 wxPyEndAllowThreads(__tstate);
14435 if (PyErr_Occurred()) SWIG_fail;
14436 }
14437 resultobj = result;
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj;
14446 wxFileType *arg1 = (wxFileType *) 0 ;
14447 wxString *arg2 = 0 ;
14448 wxString const &arg3_defvalue = wxPyEmptyString ;
14449 wxString *arg3 = (wxString *) &arg3_defvalue ;
14450 PyObject *result;
14451 bool temp2 = false ;
14452 bool temp3 = false ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 char *kwnames[] = {
14457 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14458 };
14459
14460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14462 if (SWIG_arg_fail(1)) SWIG_fail;
14463 {
14464 arg2 = wxString_in_helper(obj1);
14465 if (arg2 == NULL) SWIG_fail;
14466 temp2 = true;
14467 }
14468 if (obj2) {
14469 {
14470 arg3 = wxString_in_helper(obj2);
14471 if (arg3 == NULL) SWIG_fail;
14472 temp3 = true;
14473 }
14474 }
14475 {
14476 PyThreadState* __tstate = wxPyBeginAllowThreads();
14477 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14478
14479 wxPyEndAllowThreads(__tstate);
14480 if (PyErr_Occurred()) SWIG_fail;
14481 }
14482 resultobj = result;
14483 {
14484 if (temp2)
14485 delete arg2;
14486 }
14487 {
14488 if (temp3)
14489 delete arg3;
14490 }
14491 return resultobj;
14492 fail:
14493 {
14494 if (temp2)
14495 delete arg2;
14496 }
14497 {
14498 if (temp3)
14499 delete arg3;
14500 }
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj;
14507 wxFileType *arg1 = (wxFileType *) 0 ;
14508 wxString *arg2 = 0 ;
14509 wxString const &arg3_defvalue = wxPyEmptyString ;
14510 wxString *arg3 = (wxString *) &arg3_defvalue ;
14511 PyObject *result;
14512 bool temp2 = false ;
14513 bool temp3 = false ;
14514 PyObject * obj0 = 0 ;
14515 PyObject * obj1 = 0 ;
14516 PyObject * obj2 = 0 ;
14517 char *kwnames[] = {
14518 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14519 };
14520
14521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14523 if (SWIG_arg_fail(1)) SWIG_fail;
14524 {
14525 arg2 = wxString_in_helper(obj1);
14526 if (arg2 == NULL) SWIG_fail;
14527 temp2 = true;
14528 }
14529 if (obj2) {
14530 {
14531 arg3 = wxString_in_helper(obj2);
14532 if (arg3 == NULL) SWIG_fail;
14533 temp3 = true;
14534 }
14535 }
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14539
14540 wxPyEndAllowThreads(__tstate);
14541 if (PyErr_Occurred()) SWIG_fail;
14542 }
14543 resultobj = result;
14544 {
14545 if (temp2)
14546 delete arg2;
14547 }
14548 {
14549 if (temp3)
14550 delete arg3;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 {
14559 if (temp3)
14560 delete arg3;
14561 }
14562 return NULL;
14563 }
14564
14565
14566 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj;
14568 wxFileType *arg1 = (wxFileType *) 0 ;
14569 wxString *arg2 = 0 ;
14570 wxString const &arg3_defvalue = wxPyEmptyString ;
14571 wxString *arg3 = (wxString *) &arg3_defvalue ;
14572 PyObject *result;
14573 bool temp2 = false ;
14574 bool temp3 = false ;
14575 PyObject * obj0 = 0 ;
14576 PyObject * obj1 = 0 ;
14577 PyObject * obj2 = 0 ;
14578 char *kwnames[] = {
14579 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14580 };
14581
14582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14584 if (SWIG_arg_fail(1)) SWIG_fail;
14585 {
14586 arg2 = wxString_in_helper(obj1);
14587 if (arg2 == NULL) SWIG_fail;
14588 temp2 = true;
14589 }
14590 if (obj2) {
14591 {
14592 arg3 = wxString_in_helper(obj2);
14593 if (arg3 == NULL) SWIG_fail;
14594 temp3 = true;
14595 }
14596 }
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 resultobj = result;
14605 {
14606 if (temp2)
14607 delete arg2;
14608 }
14609 {
14610 if (temp3)
14611 delete arg3;
14612 }
14613 return resultobj;
14614 fail:
14615 {
14616 if (temp2)
14617 delete arg2;
14618 }
14619 {
14620 if (temp3)
14621 delete arg3;
14622 }
14623 return NULL;
14624 }
14625
14626
14627 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14628 PyObject *resultobj;
14629 wxFileType *arg1 = (wxFileType *) 0 ;
14630 wxString *arg2 = 0 ;
14631 wxString *arg3 = 0 ;
14632 bool arg4 = (bool) true ;
14633 bool result;
14634 bool temp2 = false ;
14635 bool temp3 = false ;
14636 PyObject * obj0 = 0 ;
14637 PyObject * obj1 = 0 ;
14638 PyObject * obj2 = 0 ;
14639 PyObject * obj3 = 0 ;
14640 char *kwnames[] = {
14641 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14642 };
14643
14644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14646 if (SWIG_arg_fail(1)) SWIG_fail;
14647 {
14648 arg2 = wxString_in_helper(obj1);
14649 if (arg2 == NULL) SWIG_fail;
14650 temp2 = true;
14651 }
14652 {
14653 arg3 = wxString_in_helper(obj2);
14654 if (arg3 == NULL) SWIG_fail;
14655 temp3 = true;
14656 }
14657 if (obj3) {
14658 {
14659 arg4 = (bool)(SWIG_As_bool(obj3));
14660 if (SWIG_arg_fail(4)) SWIG_fail;
14661 }
14662 }
14663 {
14664 PyThreadState* __tstate = wxPyBeginAllowThreads();
14665 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14666
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14672 }
14673 {
14674 if (temp2)
14675 delete arg2;
14676 }
14677 {
14678 if (temp3)
14679 delete arg3;
14680 }
14681 return resultobj;
14682 fail:
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 {
14688 if (temp3)
14689 delete arg3;
14690 }
14691 return NULL;
14692 }
14693
14694
14695 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14696 PyObject *resultobj;
14697 wxFileType *arg1 = (wxFileType *) 0 ;
14698 wxString const &arg2_defvalue = wxPyEmptyString ;
14699 wxString *arg2 = (wxString *) &arg2_defvalue ;
14700 int arg3 = (int) 0 ;
14701 bool result;
14702 bool temp2 = false ;
14703 PyObject * obj0 = 0 ;
14704 PyObject * obj1 = 0 ;
14705 PyObject * obj2 = 0 ;
14706 char *kwnames[] = {
14707 (char *) "self",(char *) "cmd",(char *) "index", NULL
14708 };
14709
14710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14712 if (SWIG_arg_fail(1)) SWIG_fail;
14713 if (obj1) {
14714 {
14715 arg2 = wxString_in_helper(obj1);
14716 if (arg2 == NULL) SWIG_fail;
14717 temp2 = true;
14718 }
14719 }
14720 if (obj2) {
14721 {
14722 arg3 = (int)(SWIG_As_int(obj2));
14723 if (SWIG_arg_fail(3)) SWIG_fail;
14724 }
14725 }
14726 {
14727 PyThreadState* __tstate = wxPyBeginAllowThreads();
14728 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14729
14730 wxPyEndAllowThreads(__tstate);
14731 if (PyErr_Occurred()) SWIG_fail;
14732 }
14733 {
14734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14735 }
14736 {
14737 if (temp2)
14738 delete arg2;
14739 }
14740 return resultobj;
14741 fail:
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 return NULL;
14747 }
14748
14749
14750 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14751 PyObject *resultobj;
14752 wxFileType *arg1 = (wxFileType *) 0 ;
14753 bool result;
14754 PyObject * obj0 = 0 ;
14755 char *kwnames[] = {
14756 (char *) "self", NULL
14757 };
14758
14759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14761 if (SWIG_arg_fail(1)) SWIG_fail;
14762 {
14763 PyThreadState* __tstate = wxPyBeginAllowThreads();
14764 result = (bool)(arg1)->Unassociate();
14765
14766 wxPyEndAllowThreads(__tstate);
14767 if (PyErr_Occurred()) SWIG_fail;
14768 }
14769 {
14770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14771 }
14772 return resultobj;
14773 fail:
14774 return NULL;
14775 }
14776
14777
14778 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14779 PyObject *resultobj;
14780 wxString *arg1 = 0 ;
14781 wxString *arg2 = 0 ;
14782 wxString const &arg3_defvalue = wxPyEmptyString ;
14783 wxString *arg3 = (wxString *) &arg3_defvalue ;
14784 wxString result;
14785 bool temp1 = false ;
14786 bool temp2 = false ;
14787 bool temp3 = false ;
14788 PyObject * obj0 = 0 ;
14789 PyObject * obj1 = 0 ;
14790 PyObject * obj2 = 0 ;
14791 char *kwnames[] = {
14792 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14793 };
14794
14795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14796 {
14797 arg1 = wxString_in_helper(obj0);
14798 if (arg1 == NULL) SWIG_fail;
14799 temp1 = true;
14800 }
14801 {
14802 arg2 = wxString_in_helper(obj1);
14803 if (arg2 == NULL) SWIG_fail;
14804 temp2 = true;
14805 }
14806 if (obj2) {
14807 {
14808 arg3 = wxString_in_helper(obj2);
14809 if (arg3 == NULL) SWIG_fail;
14810 temp3 = true;
14811 }
14812 }
14813 {
14814 PyThreadState* __tstate = wxPyBeginAllowThreads();
14815 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14816
14817 wxPyEndAllowThreads(__tstate);
14818 if (PyErr_Occurred()) SWIG_fail;
14819 }
14820 {
14821 #if wxUSE_UNICODE
14822 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14823 #else
14824 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14825 #endif
14826 }
14827 {
14828 if (temp1)
14829 delete arg1;
14830 }
14831 {
14832 if (temp2)
14833 delete arg2;
14834 }
14835 {
14836 if (temp3)
14837 delete arg3;
14838 }
14839 return resultobj;
14840 fail:
14841 {
14842 if (temp1)
14843 delete arg1;
14844 }
14845 {
14846 if (temp2)
14847 delete arg2;
14848 }
14849 {
14850 if (temp3)
14851 delete arg3;
14852 }
14853 return NULL;
14854 }
14855
14856
14857 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14858 PyObject *obj;
14859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14860 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14861 Py_INCREF(obj);
14862 return Py_BuildValue((char *)"");
14863 }
14864 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14865 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14866 return 1;
14867 }
14868
14869
14870 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14871 PyObject *pyobj;
14872
14873 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14874 return pyobj;
14875 }
14876
14877
14878 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj;
14880 wxString *arg1 = 0 ;
14881 wxString *arg2 = 0 ;
14882 bool result;
14883 bool temp1 = false ;
14884 bool temp2 = false ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 char *kwnames[] = {
14888 (char *) "mimeType",(char *) "wildcard", NULL
14889 };
14890
14891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14892 {
14893 arg1 = wxString_in_helper(obj0);
14894 if (arg1 == NULL) SWIG_fail;
14895 temp1 = true;
14896 }
14897 {
14898 arg2 = wxString_in_helper(obj1);
14899 if (arg2 == NULL) SWIG_fail;
14900 temp2 = true;
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14905
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 {
14913 if (temp1)
14914 delete arg1;
14915 }
14916 {
14917 if (temp2)
14918 delete arg2;
14919 }
14920 return resultobj;
14921 fail:
14922 {
14923 if (temp1)
14924 delete arg1;
14925 }
14926 {
14927 if (temp2)
14928 delete arg2;
14929 }
14930 return NULL;
14931 }
14932
14933
14934 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14935 PyObject *resultobj;
14936 wxMimeTypesManager *result;
14937 char *kwnames[] = {
14938 NULL
14939 };
14940
14941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14942 {
14943 PyThreadState* __tstate = wxPyBeginAllowThreads();
14944 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14945
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14950 return resultobj;
14951 fail:
14952 return NULL;
14953 }
14954
14955
14956 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14957 PyObject *resultobj;
14958 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14959 int arg2 = (int) wxMAILCAP_ALL ;
14960 wxString const &arg3_defvalue = wxPyEmptyString ;
14961 wxString *arg3 = (wxString *) &arg3_defvalue ;
14962 bool temp3 = false ;
14963 PyObject * obj0 = 0 ;
14964 PyObject * obj1 = 0 ;
14965 PyObject * obj2 = 0 ;
14966 char *kwnames[] = {
14967 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14968 };
14969
14970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14972 if (SWIG_arg_fail(1)) SWIG_fail;
14973 if (obj1) {
14974 {
14975 arg2 = (int)(SWIG_As_int(obj1));
14976 if (SWIG_arg_fail(2)) SWIG_fail;
14977 }
14978 }
14979 if (obj2) {
14980 {
14981 arg3 = wxString_in_helper(obj2);
14982 if (arg3 == NULL) SWIG_fail;
14983 temp3 = true;
14984 }
14985 }
14986 {
14987 PyThreadState* __tstate = wxPyBeginAllowThreads();
14988 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14989
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 Py_INCREF(Py_None); resultobj = Py_None;
14994 {
14995 if (temp3)
14996 delete arg3;
14997 }
14998 return resultobj;
14999 fail:
15000 {
15001 if (temp3)
15002 delete arg3;
15003 }
15004 return NULL;
15005 }
15006
15007
15008 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15009 PyObject *resultobj;
15010 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15011 PyObject * obj0 = 0 ;
15012 char *kwnames[] = {
15013 (char *) "self", NULL
15014 };
15015
15016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15018 if (SWIG_arg_fail(1)) SWIG_fail;
15019 {
15020 PyThreadState* __tstate = wxPyBeginAllowThreads();
15021 (arg1)->ClearData();
15022
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 Py_INCREF(Py_None); resultobj = Py_None;
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15034 PyObject *resultobj;
15035 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15036 wxString *arg2 = 0 ;
15037 wxFileType *result;
15038 bool temp2 = false ;
15039 PyObject * obj0 = 0 ;
15040 PyObject * obj1 = 0 ;
15041 char *kwnames[] = {
15042 (char *) "self",(char *) "ext", NULL
15043 };
15044
15045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15047 if (SWIG_arg_fail(1)) SWIG_fail;
15048 {
15049 arg2 = wxString_in_helper(obj1);
15050 if (arg2 == NULL) SWIG_fail;
15051 temp2 = true;
15052 }
15053 {
15054 PyThreadState* __tstate = wxPyBeginAllowThreads();
15055 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15056
15057 wxPyEndAllowThreads(__tstate);
15058 if (PyErr_Occurred()) SWIG_fail;
15059 }
15060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15061 {
15062 if (temp2)
15063 delete arg2;
15064 }
15065 return resultobj;
15066 fail:
15067 {
15068 if (temp2)
15069 delete arg2;
15070 }
15071 return NULL;
15072 }
15073
15074
15075 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15076 PyObject *resultobj;
15077 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15078 wxString *arg2 = 0 ;
15079 wxFileType *result;
15080 bool temp2 = false ;
15081 PyObject * obj0 = 0 ;
15082 PyObject * obj1 = 0 ;
15083 char *kwnames[] = {
15084 (char *) "self",(char *) "mimeType", NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(1)) SWIG_fail;
15090 {
15091 arg2 = wxString_in_helper(obj1);
15092 if (arg2 == NULL) SWIG_fail;
15093 temp2 = true;
15094 }
15095 {
15096 PyThreadState* __tstate = wxPyBeginAllowThreads();
15097 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15098
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15103 {
15104 if (temp2)
15105 delete arg2;
15106 }
15107 return resultobj;
15108 fail:
15109 {
15110 if (temp2)
15111 delete arg2;
15112 }
15113 return NULL;
15114 }
15115
15116
15117 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15118 PyObject *resultobj;
15119 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15120 wxString *arg2 = 0 ;
15121 bool arg3 = (bool) false ;
15122 bool result;
15123 bool temp2 = false ;
15124 PyObject * obj0 = 0 ;
15125 PyObject * obj1 = 0 ;
15126 PyObject * obj2 = 0 ;
15127 char *kwnames[] = {
15128 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15129 };
15130
15131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15133 if (SWIG_arg_fail(1)) SWIG_fail;
15134 {
15135 arg2 = wxString_in_helper(obj1);
15136 if (arg2 == NULL) SWIG_fail;
15137 temp2 = true;
15138 }
15139 if (obj2) {
15140 {
15141 arg3 = (bool)(SWIG_As_bool(obj2));
15142 if (SWIG_arg_fail(3)) SWIG_fail;
15143 }
15144 }
15145 {
15146 PyThreadState* __tstate = wxPyBeginAllowThreads();
15147 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15148
15149 wxPyEndAllowThreads(__tstate);
15150 if (PyErr_Occurred()) SWIG_fail;
15151 }
15152 {
15153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15154 }
15155 {
15156 if (temp2)
15157 delete arg2;
15158 }
15159 return resultobj;
15160 fail:
15161 {
15162 if (temp2)
15163 delete arg2;
15164 }
15165 return NULL;
15166 }
15167
15168
15169 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15170 PyObject *resultobj;
15171 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15172 wxString *arg2 = 0 ;
15173 bool result;
15174 bool temp2 = false ;
15175 PyObject * obj0 = 0 ;
15176 PyObject * obj1 = 0 ;
15177 char *kwnames[] = {
15178 (char *) "self",(char *) "filename", NULL
15179 };
15180
15181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15183 if (SWIG_arg_fail(1)) SWIG_fail;
15184 {
15185 arg2 = wxString_in_helper(obj1);
15186 if (arg2 == NULL) SWIG_fail;
15187 temp2 = true;
15188 }
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15192
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 {
15197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15198 }
15199 {
15200 if (temp2)
15201 delete arg2;
15202 }
15203 return resultobj;
15204 fail:
15205 {
15206 if (temp2)
15207 delete arg2;
15208 }
15209 return NULL;
15210 }
15211
15212
15213 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15214 PyObject *resultobj;
15215 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15216 PyObject *result;
15217 PyObject * obj0 = 0 ;
15218 char *kwnames[] = {
15219 (char *) "self", NULL
15220 };
15221
15222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15224 if (SWIG_arg_fail(1)) SWIG_fail;
15225 {
15226 PyThreadState* __tstate = wxPyBeginAllowThreads();
15227 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15228
15229 wxPyEndAllowThreads(__tstate);
15230 if (PyErr_Occurred()) SWIG_fail;
15231 }
15232 resultobj = result;
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15240 PyObject *resultobj;
15241 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15242 wxFileTypeInfo *arg2 = 0 ;
15243 PyObject * obj0 = 0 ;
15244 PyObject * obj1 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "self",(char *) "ft", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 {
15253 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15254 if (SWIG_arg_fail(2)) SWIG_fail;
15255 if (arg2 == NULL) {
15256 SWIG_null_ref("wxFileTypeInfo");
15257 }
15258 if (SWIG_arg_fail(2)) SWIG_fail;
15259 }
15260 {
15261 PyThreadState* __tstate = wxPyBeginAllowThreads();
15262 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15263
15264 wxPyEndAllowThreads(__tstate);
15265 if (PyErr_Occurred()) SWIG_fail;
15266 }
15267 Py_INCREF(Py_None); resultobj = Py_None;
15268 return resultobj;
15269 fail:
15270 return NULL;
15271 }
15272
15273
15274 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15275 PyObject *resultobj;
15276 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15277 wxFileTypeInfo *arg2 = 0 ;
15278 wxFileType *result;
15279 PyObject * obj0 = 0 ;
15280 PyObject * obj1 = 0 ;
15281 char *kwnames[] = {
15282 (char *) "self",(char *) "ftInfo", NULL
15283 };
15284
15285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15287 if (SWIG_arg_fail(1)) SWIG_fail;
15288 {
15289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15290 if (SWIG_arg_fail(2)) SWIG_fail;
15291 if (arg2 == NULL) {
15292 SWIG_null_ref("wxFileTypeInfo");
15293 }
15294 if (SWIG_arg_fail(2)) SWIG_fail;
15295 }
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15299
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15311 PyObject *resultobj;
15312 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15313 wxFileType *arg2 = (wxFileType *) 0 ;
15314 bool result;
15315 PyObject * obj0 = 0 ;
15316 PyObject * obj1 = 0 ;
15317 char *kwnames[] = {
15318 (char *) "self",(char *) "ft", NULL
15319 };
15320
15321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15323 if (SWIG_arg_fail(1)) SWIG_fail;
15324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(2)) SWIG_fail;
15326 {
15327 PyThreadState* __tstate = wxPyBeginAllowThreads();
15328 result = (bool)(arg1)->Unassociate(arg2);
15329
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 {
15334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15335 }
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj;
15344 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15345 PyObject * obj0 = 0 ;
15346 char *kwnames[] = {
15347 (char *) "self", NULL
15348 };
15349
15350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15352 if (SWIG_arg_fail(1)) SWIG_fail;
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 delete arg1;
15356
15357 wxPyEndAllowThreads(__tstate);
15358 if (PyErr_Occurred()) SWIG_fail;
15359 }
15360 Py_INCREF(Py_None); resultobj = Py_None;
15361 return resultobj;
15362 fail:
15363 return NULL;
15364 }
15365
15366
15367 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15368 PyObject *obj;
15369 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15370 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15371 Py_INCREF(obj);
15372 return Py_BuildValue((char *)"");
15373 }
15374 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15375 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15376 return 1;
15377 }
15378
15379
15380 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15381 PyObject *pyobj;
15382
15383 {
15384 #if wxUSE_UNICODE
15385 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15386 #else
15387 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15388 #endif
15389 }
15390 return pyobj;
15391 }
15392
15393
15394 static int _wrap_ART_MENU_set(PyObject *) {
15395 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15396 return 1;
15397 }
15398
15399
15400 static PyObject *_wrap_ART_MENU_get(void) {
15401 PyObject *pyobj;
15402
15403 {
15404 #if wxUSE_UNICODE
15405 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15406 #else
15407 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15408 #endif
15409 }
15410 return pyobj;
15411 }
15412
15413
15414 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15415 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15416 return 1;
15417 }
15418
15419
15420 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15421 PyObject *pyobj;
15422
15423 {
15424 #if wxUSE_UNICODE
15425 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15426 #else
15427 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15428 #endif
15429 }
15430 return pyobj;
15431 }
15432
15433
15434 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15435 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15436 return 1;
15437 }
15438
15439
15440 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15441 PyObject *pyobj;
15442
15443 {
15444 #if wxUSE_UNICODE
15445 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15446 #else
15447 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15448 #endif
15449 }
15450 return pyobj;
15451 }
15452
15453
15454 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15455 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15456 return 1;
15457 }
15458
15459
15460 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15461 PyObject *pyobj;
15462
15463 {
15464 #if wxUSE_UNICODE
15465 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15466 #else
15467 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15468 #endif
15469 }
15470 return pyobj;
15471 }
15472
15473
15474 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15475 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15476 return 1;
15477 }
15478
15479
15480 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15481 PyObject *pyobj;
15482
15483 {
15484 #if wxUSE_UNICODE
15485 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15486 #else
15487 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15488 #endif
15489 }
15490 return pyobj;
15491 }
15492
15493
15494 static int _wrap_ART_BUTTON_set(PyObject *) {
15495 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15496 return 1;
15497 }
15498
15499
15500 static PyObject *_wrap_ART_BUTTON_get(void) {
15501 PyObject *pyobj;
15502
15503 {
15504 #if wxUSE_UNICODE
15505 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15506 #else
15507 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15508 #endif
15509 }
15510 return pyobj;
15511 }
15512
15513
15514 static int _wrap_ART_OTHER_set(PyObject *) {
15515 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15516 return 1;
15517 }
15518
15519
15520 static PyObject *_wrap_ART_OTHER_get(void) {
15521 PyObject *pyobj;
15522
15523 {
15524 #if wxUSE_UNICODE
15525 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15526 #else
15527 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15528 #endif
15529 }
15530 return pyobj;
15531 }
15532
15533
15534 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15535 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15536 return 1;
15537 }
15538
15539
15540 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15541 PyObject *pyobj;
15542
15543 {
15544 #if wxUSE_UNICODE
15545 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15546 #else
15547 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15548 #endif
15549 }
15550 return pyobj;
15551 }
15552
15553
15554 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15555 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15556 return 1;
15557 }
15558
15559
15560 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15561 PyObject *pyobj;
15562
15563 {
15564 #if wxUSE_UNICODE
15565 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15566 #else
15567 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15568 #endif
15569 }
15570 return pyobj;
15571 }
15572
15573
15574 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15575 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15576 return 1;
15577 }
15578
15579
15580 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15581 PyObject *pyobj;
15582
15583 {
15584 #if wxUSE_UNICODE
15585 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15586 #else
15587 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15588 #endif
15589 }
15590 return pyobj;
15591 }
15592
15593
15594 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15595 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15596 return 1;
15597 }
15598
15599
15600 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15601 PyObject *pyobj;
15602
15603 {
15604 #if wxUSE_UNICODE
15605 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15606 #else
15607 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15608 #endif
15609 }
15610 return pyobj;
15611 }
15612
15613
15614 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15615 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15616 return 1;
15617 }
15618
15619
15620 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15621 PyObject *pyobj;
15622
15623 {
15624 #if wxUSE_UNICODE
15625 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15626 #else
15627 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15628 #endif
15629 }
15630 return pyobj;
15631 }
15632
15633
15634 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15635 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15636 return 1;
15637 }
15638
15639
15640 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15641 PyObject *pyobj;
15642
15643 {
15644 #if wxUSE_UNICODE
15645 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15646 #else
15647 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15648 #endif
15649 }
15650 return pyobj;
15651 }
15652
15653
15654 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15655 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15656 return 1;
15657 }
15658
15659
15660 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15661 PyObject *pyobj;
15662
15663 {
15664 #if wxUSE_UNICODE
15665 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15666 #else
15667 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15668 #endif
15669 }
15670 return pyobj;
15671 }
15672
15673
15674 static int _wrap_ART_GO_BACK_set(PyObject *) {
15675 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15676 return 1;
15677 }
15678
15679
15680 static PyObject *_wrap_ART_GO_BACK_get(void) {
15681 PyObject *pyobj;
15682
15683 {
15684 #if wxUSE_UNICODE
15685 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15686 #else
15687 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15688 #endif
15689 }
15690 return pyobj;
15691 }
15692
15693
15694 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15695 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15696 return 1;
15697 }
15698
15699
15700 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15701 PyObject *pyobj;
15702
15703 {
15704 #if wxUSE_UNICODE
15705 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15706 #else
15707 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15708 #endif
15709 }
15710 return pyobj;
15711 }
15712
15713
15714 static int _wrap_ART_GO_UP_set(PyObject *) {
15715 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15716 return 1;
15717 }
15718
15719
15720 static PyObject *_wrap_ART_GO_UP_get(void) {
15721 PyObject *pyobj;
15722
15723 {
15724 #if wxUSE_UNICODE
15725 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15726 #else
15727 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15728 #endif
15729 }
15730 return pyobj;
15731 }
15732
15733
15734 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15735 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15736 return 1;
15737 }
15738
15739
15740 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15741 PyObject *pyobj;
15742
15743 {
15744 #if wxUSE_UNICODE
15745 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15746 #else
15747 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15748 #endif
15749 }
15750 return pyobj;
15751 }
15752
15753
15754 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15755 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15756 return 1;
15757 }
15758
15759
15760 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15761 PyObject *pyobj;
15762
15763 {
15764 #if wxUSE_UNICODE
15765 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15766 #else
15767 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15768 #endif
15769 }
15770 return pyobj;
15771 }
15772
15773
15774 static int _wrap_ART_GO_HOME_set(PyObject *) {
15775 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15776 return 1;
15777 }
15778
15779
15780 static PyObject *_wrap_ART_GO_HOME_get(void) {
15781 PyObject *pyobj;
15782
15783 {
15784 #if wxUSE_UNICODE
15785 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15786 #else
15787 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15788 #endif
15789 }
15790 return pyobj;
15791 }
15792
15793
15794 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15795 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15796 return 1;
15797 }
15798
15799
15800 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15801 PyObject *pyobj;
15802
15803 {
15804 #if wxUSE_UNICODE
15805 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15806 #else
15807 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15808 #endif
15809 }
15810 return pyobj;
15811 }
15812
15813
15814 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15815 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15816 return 1;
15817 }
15818
15819
15820 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15821 PyObject *pyobj;
15822
15823 {
15824 #if wxUSE_UNICODE
15825 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15826 #else
15827 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15828 #endif
15829 }
15830 return pyobj;
15831 }
15832
15833
15834 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15835 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15836 return 1;
15837 }
15838
15839
15840 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15841 PyObject *pyobj;
15842
15843 {
15844 #if wxUSE_UNICODE
15845 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15846 #else
15847 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15848 #endif
15849 }
15850 return pyobj;
15851 }
15852
15853
15854 static int _wrap_ART_PRINT_set(PyObject *) {
15855 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15856 return 1;
15857 }
15858
15859
15860 static PyObject *_wrap_ART_PRINT_get(void) {
15861 PyObject *pyobj;
15862
15863 {
15864 #if wxUSE_UNICODE
15865 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15866 #else
15867 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15868 #endif
15869 }
15870 return pyobj;
15871 }
15872
15873
15874 static int _wrap_ART_HELP_set(PyObject *) {
15875 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15876 return 1;
15877 }
15878
15879
15880 static PyObject *_wrap_ART_HELP_get(void) {
15881 PyObject *pyobj;
15882
15883 {
15884 #if wxUSE_UNICODE
15885 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15886 #else
15887 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15888 #endif
15889 }
15890 return pyobj;
15891 }
15892
15893
15894 static int _wrap_ART_TIP_set(PyObject *) {
15895 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15896 return 1;
15897 }
15898
15899
15900 static PyObject *_wrap_ART_TIP_get(void) {
15901 PyObject *pyobj;
15902
15903 {
15904 #if wxUSE_UNICODE
15905 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15906 #else
15907 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15908 #endif
15909 }
15910 return pyobj;
15911 }
15912
15913
15914 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15915 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15916 return 1;
15917 }
15918
15919
15920 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15921 PyObject *pyobj;
15922
15923 {
15924 #if wxUSE_UNICODE
15925 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15926 #else
15927 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15928 #endif
15929 }
15930 return pyobj;
15931 }
15932
15933
15934 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15935 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15936 return 1;
15937 }
15938
15939
15940 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15941 PyObject *pyobj;
15942
15943 {
15944 #if wxUSE_UNICODE
15945 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15946 #else
15947 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15948 #endif
15949 }
15950 return pyobj;
15951 }
15952
15953
15954 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15955 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15956 return 1;
15957 }
15958
15959
15960 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15961 PyObject *pyobj;
15962
15963 {
15964 #if wxUSE_UNICODE
15965 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15966 #else
15967 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15968 #endif
15969 }
15970 return pyobj;
15971 }
15972
15973
15974 static int _wrap_ART_HARDDISK_set(PyObject *) {
15975 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15976 return 1;
15977 }
15978
15979
15980 static PyObject *_wrap_ART_HARDDISK_get(void) {
15981 PyObject *pyobj;
15982
15983 {
15984 #if wxUSE_UNICODE
15985 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15986 #else
15987 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15988 #endif
15989 }
15990 return pyobj;
15991 }
15992
15993
15994 static int _wrap_ART_FLOPPY_set(PyObject *) {
15995 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15996 return 1;
15997 }
15998
15999
16000 static PyObject *_wrap_ART_FLOPPY_get(void) {
16001 PyObject *pyobj;
16002
16003 {
16004 #if wxUSE_UNICODE
16005 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16006 #else
16007 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
16008 #endif
16009 }
16010 return pyobj;
16011 }
16012
16013
16014 static int _wrap_ART_CDROM_set(PyObject *) {
16015 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16016 return 1;
16017 }
16018
16019
16020 static PyObject *_wrap_ART_CDROM_get(void) {
16021 PyObject *pyobj;
16022
16023 {
16024 #if wxUSE_UNICODE
16025 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16026 #else
16027 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16028 #endif
16029 }
16030 return pyobj;
16031 }
16032
16033
16034 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16035 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16036 return 1;
16037 }
16038
16039
16040 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16041 PyObject *pyobj;
16042
16043 {
16044 #if wxUSE_UNICODE
16045 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16046 #else
16047 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16048 #endif
16049 }
16050 return pyobj;
16051 }
16052
16053
16054 static int _wrap_ART_FOLDER_set(PyObject *) {
16055 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16056 return 1;
16057 }
16058
16059
16060 static PyObject *_wrap_ART_FOLDER_get(void) {
16061 PyObject *pyobj;
16062
16063 {
16064 #if wxUSE_UNICODE
16065 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16066 #else
16067 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16068 #endif
16069 }
16070 return pyobj;
16071 }
16072
16073
16074 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16075 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16076 return 1;
16077 }
16078
16079
16080 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16081 PyObject *pyobj;
16082
16083 {
16084 #if wxUSE_UNICODE
16085 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16086 #else
16087 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16088 #endif
16089 }
16090 return pyobj;
16091 }
16092
16093
16094 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16095 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16096 return 1;
16097 }
16098
16099
16100 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16101 PyObject *pyobj;
16102
16103 {
16104 #if wxUSE_UNICODE
16105 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16106 #else
16107 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16108 #endif
16109 }
16110 return pyobj;
16111 }
16112
16113
16114 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16115 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16116 return 1;
16117 }
16118
16119
16120 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16121 PyObject *pyobj;
16122
16123 {
16124 #if wxUSE_UNICODE
16125 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16126 #else
16127 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16128 #endif
16129 }
16130 return pyobj;
16131 }
16132
16133
16134 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16135 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16136 return 1;
16137 }
16138
16139
16140 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16141 PyObject *pyobj;
16142
16143 {
16144 #if wxUSE_UNICODE
16145 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16146 #else
16147 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16148 #endif
16149 }
16150 return pyobj;
16151 }
16152
16153
16154 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16155 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16156 return 1;
16157 }
16158
16159
16160 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16161 PyObject *pyobj;
16162
16163 {
16164 #if wxUSE_UNICODE
16165 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16166 #else
16167 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16168 #endif
16169 }
16170 return pyobj;
16171 }
16172
16173
16174 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16175 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16176 return 1;
16177 }
16178
16179
16180 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16181 PyObject *pyobj;
16182
16183 {
16184 #if wxUSE_UNICODE
16185 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16186 #else
16187 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16188 #endif
16189 }
16190 return pyobj;
16191 }
16192
16193
16194 static int _wrap_ART_ERROR_set(PyObject *) {
16195 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16196 return 1;
16197 }
16198
16199
16200 static PyObject *_wrap_ART_ERROR_get(void) {
16201 PyObject *pyobj;
16202
16203 {
16204 #if wxUSE_UNICODE
16205 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16206 #else
16207 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16208 #endif
16209 }
16210 return pyobj;
16211 }
16212
16213
16214 static int _wrap_ART_QUESTION_set(PyObject *) {
16215 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16216 return 1;
16217 }
16218
16219
16220 static PyObject *_wrap_ART_QUESTION_get(void) {
16221 PyObject *pyobj;
16222
16223 {
16224 #if wxUSE_UNICODE
16225 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16226 #else
16227 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16228 #endif
16229 }
16230 return pyobj;
16231 }
16232
16233
16234 static int _wrap_ART_WARNING_set(PyObject *) {
16235 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16236 return 1;
16237 }
16238
16239
16240 static PyObject *_wrap_ART_WARNING_get(void) {
16241 PyObject *pyobj;
16242
16243 {
16244 #if wxUSE_UNICODE
16245 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16246 #else
16247 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16248 #endif
16249 }
16250 return pyobj;
16251 }
16252
16253
16254 static int _wrap_ART_INFORMATION_set(PyObject *) {
16255 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16256 return 1;
16257 }
16258
16259
16260 static PyObject *_wrap_ART_INFORMATION_get(void) {
16261 PyObject *pyobj;
16262
16263 {
16264 #if wxUSE_UNICODE
16265 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16266 #else
16267 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16268 #endif
16269 }
16270 return pyobj;
16271 }
16272
16273
16274 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16275 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16276 return 1;
16277 }
16278
16279
16280 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16281 PyObject *pyobj;
16282
16283 {
16284 #if wxUSE_UNICODE
16285 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16286 #else
16287 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16288 #endif
16289 }
16290 return pyobj;
16291 }
16292
16293
16294 static int _wrap_ART_COPY_set(PyObject *) {
16295 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16296 return 1;
16297 }
16298
16299
16300 static PyObject *_wrap_ART_COPY_get(void) {
16301 PyObject *pyobj;
16302
16303 {
16304 #if wxUSE_UNICODE
16305 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16306 #else
16307 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16308 #endif
16309 }
16310 return pyobj;
16311 }
16312
16313
16314 static int _wrap_ART_CUT_set(PyObject *) {
16315 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16316 return 1;
16317 }
16318
16319
16320 static PyObject *_wrap_ART_CUT_get(void) {
16321 PyObject *pyobj;
16322
16323 {
16324 #if wxUSE_UNICODE
16325 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16326 #else
16327 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16328 #endif
16329 }
16330 return pyobj;
16331 }
16332
16333
16334 static int _wrap_ART_PASTE_set(PyObject *) {
16335 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16336 return 1;
16337 }
16338
16339
16340 static PyObject *_wrap_ART_PASTE_get(void) {
16341 PyObject *pyobj;
16342
16343 {
16344 #if wxUSE_UNICODE
16345 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16346 #else
16347 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16348 #endif
16349 }
16350 return pyobj;
16351 }
16352
16353
16354 static int _wrap_ART_DELETE_set(PyObject *) {
16355 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16356 return 1;
16357 }
16358
16359
16360 static PyObject *_wrap_ART_DELETE_get(void) {
16361 PyObject *pyobj;
16362
16363 {
16364 #if wxUSE_UNICODE
16365 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16366 #else
16367 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16368 #endif
16369 }
16370 return pyobj;
16371 }
16372
16373
16374 static int _wrap_ART_UNDO_set(PyObject *) {
16375 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16376 return 1;
16377 }
16378
16379
16380 static PyObject *_wrap_ART_UNDO_get(void) {
16381 PyObject *pyobj;
16382
16383 {
16384 #if wxUSE_UNICODE
16385 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16386 #else
16387 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16388 #endif
16389 }
16390 return pyobj;
16391 }
16392
16393
16394 static int _wrap_ART_REDO_set(PyObject *) {
16395 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16396 return 1;
16397 }
16398
16399
16400 static PyObject *_wrap_ART_REDO_get(void) {
16401 PyObject *pyobj;
16402
16403 {
16404 #if wxUSE_UNICODE
16405 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16406 #else
16407 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16408 #endif
16409 }
16410 return pyobj;
16411 }
16412
16413
16414 static int _wrap_ART_QUIT_set(PyObject *) {
16415 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16416 return 1;
16417 }
16418
16419
16420 static PyObject *_wrap_ART_QUIT_get(void) {
16421 PyObject *pyobj;
16422
16423 {
16424 #if wxUSE_UNICODE
16425 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16426 #else
16427 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16428 #endif
16429 }
16430 return pyobj;
16431 }
16432
16433
16434 static int _wrap_ART_FIND_set(PyObject *) {
16435 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16436 return 1;
16437 }
16438
16439
16440 static PyObject *_wrap_ART_FIND_get(void) {
16441 PyObject *pyobj;
16442
16443 {
16444 #if wxUSE_UNICODE
16445 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16446 #else
16447 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16448 #endif
16449 }
16450 return pyobj;
16451 }
16452
16453
16454 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16455 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16456 return 1;
16457 }
16458
16459
16460 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16461 PyObject *pyobj;
16462
16463 {
16464 #if wxUSE_UNICODE
16465 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16466 #else
16467 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16468 #endif
16469 }
16470 return pyobj;
16471 }
16472
16473
16474 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16475 PyObject *resultobj;
16476 wxPyArtProvider *result;
16477 char *kwnames[] = {
16478 NULL
16479 };
16480
16481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16482 {
16483 if (!wxPyCheckForApp()) SWIG_fail;
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 result = (wxPyArtProvider *)new wxPyArtProvider();
16486
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj;
16499 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16500 PyObject *arg2 = (PyObject *) 0 ;
16501 PyObject *arg3 = (PyObject *) 0 ;
16502 PyObject * obj0 = 0 ;
16503 PyObject * obj1 = 0 ;
16504 PyObject * obj2 = 0 ;
16505 char *kwnames[] = {
16506 (char *) "self",(char *) "self",(char *) "_class", NULL
16507 };
16508
16509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16511 if (SWIG_arg_fail(1)) SWIG_fail;
16512 arg2 = obj1;
16513 arg3 = obj2;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 (arg1)->_setCallbackInfo(arg2,arg3);
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 Py_INCREF(Py_None); resultobj = Py_None;
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16531 PyObject * obj0 = 0 ;
16532 char *kwnames[] = {
16533 (char *) "provider", NULL
16534 };
16535
16536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16538 if (SWIG_arg_fail(1)) SWIG_fail;
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 wxPyArtProvider::PushProvider(arg1);
16542
16543 wxPyEndAllowThreads(__tstate);
16544 if (PyErr_Occurred()) SWIG_fail;
16545 }
16546 Py_INCREF(Py_None); resultobj = Py_None;
16547 return resultobj;
16548 fail:
16549 return NULL;
16550 }
16551
16552
16553 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16554 PyObject *resultobj;
16555 bool result;
16556 char *kwnames[] = {
16557 NULL
16558 };
16559
16560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16561 {
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = (bool)wxPyArtProvider::PopProvider();
16564
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 {
16569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16570 }
16571 return resultobj;
16572 fail:
16573 return NULL;
16574 }
16575
16576
16577 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16578 PyObject *resultobj;
16579 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16580 bool result;
16581 PyObject * obj0 = 0 ;
16582 char *kwnames[] = {
16583 (char *) "provider", NULL
16584 };
16585
16586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16588 if (SWIG_arg_fail(1)) SWIG_fail;
16589 {
16590 PyThreadState* __tstate = wxPyBeginAllowThreads();
16591 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16592
16593 wxPyEndAllowThreads(__tstate);
16594 if (PyErr_Occurred()) SWIG_fail;
16595 }
16596 {
16597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16598 }
16599 return resultobj;
16600 fail:
16601 return NULL;
16602 }
16603
16604
16605 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16606 PyObject *resultobj;
16607 wxString *arg1 = 0 ;
16608 wxString const &arg2_defvalue = wxPyART_OTHER ;
16609 wxString *arg2 = (wxString *) &arg2_defvalue ;
16610 wxSize const &arg3_defvalue = wxDefaultSize ;
16611 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16612 wxBitmap result;
16613 bool temp1 = false ;
16614 bool temp2 = false ;
16615 wxSize temp3 ;
16616 PyObject * obj0 = 0 ;
16617 PyObject * obj1 = 0 ;
16618 PyObject * obj2 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "id",(char *) "client",(char *) "size", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16624 {
16625 arg1 = wxString_in_helper(obj0);
16626 if (arg1 == NULL) SWIG_fail;
16627 temp1 = true;
16628 }
16629 if (obj1) {
16630 {
16631 arg2 = wxString_in_helper(obj1);
16632 if (arg2 == NULL) SWIG_fail;
16633 temp2 = true;
16634 }
16635 }
16636 if (obj2) {
16637 {
16638 arg3 = &temp3;
16639 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16640 }
16641 }
16642 {
16643 if (!wxPyCheckForApp()) SWIG_fail;
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 wxBitmap * resultptr;
16652 resultptr = new wxBitmap((wxBitmap &)(result));
16653 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16654 }
16655 {
16656 if (temp1)
16657 delete arg1;
16658 }
16659 {
16660 if (temp2)
16661 delete arg2;
16662 }
16663 return resultobj;
16664 fail:
16665 {
16666 if (temp1)
16667 delete arg1;
16668 }
16669 {
16670 if (temp2)
16671 delete arg2;
16672 }
16673 return NULL;
16674 }
16675
16676
16677 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16678 PyObject *resultobj;
16679 wxString *arg1 = 0 ;
16680 wxString const &arg2_defvalue = wxPyART_OTHER ;
16681 wxString *arg2 = (wxString *) &arg2_defvalue ;
16682 wxSize const &arg3_defvalue = wxDefaultSize ;
16683 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16684 wxIcon result;
16685 bool temp1 = false ;
16686 bool temp2 = false ;
16687 wxSize temp3 ;
16688 PyObject * obj0 = 0 ;
16689 PyObject * obj1 = 0 ;
16690 PyObject * obj2 = 0 ;
16691 char *kwnames[] = {
16692 (char *) "id",(char *) "client",(char *) "size", NULL
16693 };
16694
16695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16696 {
16697 arg1 = wxString_in_helper(obj0);
16698 if (arg1 == NULL) SWIG_fail;
16699 temp1 = true;
16700 }
16701 if (obj1) {
16702 {
16703 arg2 = wxString_in_helper(obj1);
16704 if (arg2 == NULL) SWIG_fail;
16705 temp2 = true;
16706 }
16707 }
16708 if (obj2) {
16709 {
16710 arg3 = &temp3;
16711 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16712 }
16713 }
16714 {
16715 if (!wxPyCheckForApp()) SWIG_fail;
16716 PyThreadState* __tstate = wxPyBeginAllowThreads();
16717 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16718
16719 wxPyEndAllowThreads(__tstate);
16720 if (PyErr_Occurred()) SWIG_fail;
16721 }
16722 {
16723 wxIcon * resultptr;
16724 resultptr = new wxIcon((wxIcon &)(result));
16725 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16726 }
16727 {
16728 if (temp1)
16729 delete arg1;
16730 }
16731 {
16732 if (temp2)
16733 delete arg2;
16734 }
16735 return resultobj;
16736 fail:
16737 {
16738 if (temp1)
16739 delete arg1;
16740 }
16741 {
16742 if (temp2)
16743 delete arg2;
16744 }
16745 return NULL;
16746 }
16747
16748
16749 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16750 PyObject *resultobj;
16751 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 {
16761 PyThreadState* __tstate = wxPyBeginAllowThreads();
16762 wxPyArtProvider_Destroy(arg1);
16763
16764 wxPyEndAllowThreads(__tstate);
16765 if (PyErr_Occurred()) SWIG_fail;
16766 }
16767 Py_INCREF(Py_None); resultobj = Py_None;
16768 return resultobj;
16769 fail:
16770 return NULL;
16771 }
16772
16773
16774 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16775 PyObject *obj;
16776 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16777 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16778 Py_INCREF(obj);
16779 return Py_BuildValue((char *)"");
16780 }
16781 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj;
16783 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 delete arg1;
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 Py_INCREF(Py_None); resultobj = Py_None;
16800 return resultobj;
16801 fail:
16802 return NULL;
16803 }
16804
16805
16806 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16807 PyObject *resultobj;
16808 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16809 wxConfigBase *result;
16810 PyObject * obj0 = 0 ;
16811 char *kwnames[] = {
16812 (char *) "config", NULL
16813 };
16814
16815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16817 if (SWIG_arg_fail(1)) SWIG_fail;
16818 {
16819 PyThreadState* __tstate = wxPyBeginAllowThreads();
16820 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16821
16822 wxPyEndAllowThreads(__tstate);
16823 if (PyErr_Occurred()) SWIG_fail;
16824 }
16825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16826 return resultobj;
16827 fail:
16828 return NULL;
16829 }
16830
16831
16832 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16833 PyObject *resultobj;
16834 bool arg1 = (bool) true ;
16835 wxConfigBase *result;
16836 PyObject * obj0 = 0 ;
16837 char *kwnames[] = {
16838 (char *) "createOnDemand", NULL
16839 };
16840
16841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16842 if (obj0) {
16843 {
16844 arg1 = (bool)(SWIG_As_bool(obj0));
16845 if (SWIG_arg_fail(1)) SWIG_fail;
16846 }
16847 }
16848 {
16849 PyThreadState* __tstate = wxPyBeginAllowThreads();
16850 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16851
16852 wxPyEndAllowThreads(__tstate);
16853 if (PyErr_Occurred()) SWIG_fail;
16854 }
16855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16856 return resultobj;
16857 fail:
16858 return NULL;
16859 }
16860
16861
16862 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16863 PyObject *resultobj;
16864 wxConfigBase *result;
16865 char *kwnames[] = {
16866 NULL
16867 };
16868
16869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16870 {
16871 PyThreadState* __tstate = wxPyBeginAllowThreads();
16872 result = (wxConfigBase *)wxConfigBase::Create();
16873
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16885 PyObject *resultobj;
16886 char *kwnames[] = {
16887 NULL
16888 };
16889
16890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16891 {
16892 PyThreadState* __tstate = wxPyBeginAllowThreads();
16893 wxConfigBase::DontCreateOnDemand();
16894
16895 wxPyEndAllowThreads(__tstate);
16896 if (PyErr_Occurred()) SWIG_fail;
16897 }
16898 Py_INCREF(Py_None); resultobj = Py_None;
16899 return resultobj;
16900 fail:
16901 return NULL;
16902 }
16903
16904
16905 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16906 PyObject *resultobj;
16907 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16908 wxString *arg2 = 0 ;
16909 bool temp2 = false ;
16910 PyObject * obj0 = 0 ;
16911 PyObject * obj1 = 0 ;
16912 char *kwnames[] = {
16913 (char *) "self",(char *) "path", NULL
16914 };
16915
16916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16918 if (SWIG_arg_fail(1)) SWIG_fail;
16919 {
16920 arg2 = wxString_in_helper(obj1);
16921 if (arg2 == NULL) SWIG_fail;
16922 temp2 = true;
16923 }
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 (arg1)->SetPath((wxString const &)*arg2);
16927
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 Py_INCREF(Py_None); resultobj = Py_None;
16932 {
16933 if (temp2)
16934 delete arg2;
16935 }
16936 return resultobj;
16937 fail:
16938 {
16939 if (temp2)
16940 delete arg2;
16941 }
16942 return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16947 PyObject *resultobj;
16948 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16949 wxString *result;
16950 PyObject * obj0 = 0 ;
16951 char *kwnames[] = {
16952 (char *) "self", NULL
16953 };
16954
16955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16957 if (SWIG_arg_fail(1)) SWIG_fail;
16958 {
16959 PyThreadState* __tstate = wxPyBeginAllowThreads();
16960 {
16961 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16962 result = (wxString *) &_result_ref;
16963 }
16964
16965 wxPyEndAllowThreads(__tstate);
16966 if (PyErr_Occurred()) SWIG_fail;
16967 }
16968 {
16969 #if wxUSE_UNICODE
16970 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16971 #else
16972 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16973 #endif
16974 }
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj;
16983 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16984 PyObject *result;
16985 PyObject * obj0 = 0 ;
16986 char *kwnames[] = {
16987 (char *) "self", NULL
16988 };
16989
16990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16992 if (SWIG_arg_fail(1)) SWIG_fail;
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16996
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 resultobj = result;
17001 return resultobj;
17002 fail:
17003 return NULL;
17004 }
17005
17006
17007 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj;
17009 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17010 long arg2 ;
17011 PyObject *result;
17012 PyObject * obj0 = 0 ;
17013 PyObject * obj1 = 0 ;
17014 char *kwnames[] = {
17015 (char *) "self",(char *) "index", NULL
17016 };
17017
17018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17020 if (SWIG_arg_fail(1)) SWIG_fail;
17021 {
17022 arg2 = (long)(SWIG_As_long(obj1));
17023 if (SWIG_arg_fail(2)) SWIG_fail;
17024 }
17025 {
17026 PyThreadState* __tstate = wxPyBeginAllowThreads();
17027 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17028
17029 wxPyEndAllowThreads(__tstate);
17030 if (PyErr_Occurred()) SWIG_fail;
17031 }
17032 resultobj = result;
17033 return resultobj;
17034 fail:
17035 return NULL;
17036 }
17037
17038
17039 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17040 PyObject *resultobj;
17041 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17042 PyObject *result;
17043 PyObject * obj0 = 0 ;
17044 char *kwnames[] = {
17045 (char *) "self", NULL
17046 };
17047
17048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17050 if (SWIG_arg_fail(1)) SWIG_fail;
17051 {
17052 PyThreadState* __tstate = wxPyBeginAllowThreads();
17053 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17054
17055 wxPyEndAllowThreads(__tstate);
17056 if (PyErr_Occurred()) SWIG_fail;
17057 }
17058 resultobj = result;
17059 return resultobj;
17060 fail:
17061 return NULL;
17062 }
17063
17064
17065 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17066 PyObject *resultobj;
17067 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17068 long arg2 ;
17069 PyObject *result;
17070 PyObject * obj0 = 0 ;
17071 PyObject * obj1 = 0 ;
17072 char *kwnames[] = {
17073 (char *) "self",(char *) "index", NULL
17074 };
17075
17076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17078 if (SWIG_arg_fail(1)) SWIG_fail;
17079 {
17080 arg2 = (long)(SWIG_As_long(obj1));
17081 if (SWIG_arg_fail(2)) SWIG_fail;
17082 }
17083 {
17084 PyThreadState* __tstate = wxPyBeginAllowThreads();
17085 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17086
17087 wxPyEndAllowThreads(__tstate);
17088 if (PyErr_Occurred()) SWIG_fail;
17089 }
17090 resultobj = result;
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj;
17099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17100 bool arg2 = (bool) false ;
17101 size_t result;
17102 PyObject * obj0 = 0 ;
17103 PyObject * obj1 = 0 ;
17104 char *kwnames[] = {
17105 (char *) "self",(char *) "recursive", NULL
17106 };
17107
17108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17110 if (SWIG_arg_fail(1)) SWIG_fail;
17111 if (obj1) {
17112 {
17113 arg2 = (bool)(SWIG_As_bool(obj1));
17114 if (SWIG_arg_fail(2)) SWIG_fail;
17115 }
17116 }
17117 {
17118 PyThreadState* __tstate = wxPyBeginAllowThreads();
17119 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17120
17121 wxPyEndAllowThreads(__tstate);
17122 if (PyErr_Occurred()) SWIG_fail;
17123 }
17124 {
17125 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17126 }
17127 return resultobj;
17128 fail:
17129 return NULL;
17130 }
17131
17132
17133 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17134 PyObject *resultobj;
17135 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17136 bool arg2 = (bool) false ;
17137 size_t result;
17138 PyObject * obj0 = 0 ;
17139 PyObject * obj1 = 0 ;
17140 char *kwnames[] = {
17141 (char *) "self",(char *) "recursive", NULL
17142 };
17143
17144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17146 if (SWIG_arg_fail(1)) SWIG_fail;
17147 if (obj1) {
17148 {
17149 arg2 = (bool)(SWIG_As_bool(obj1));
17150 if (SWIG_arg_fail(2)) SWIG_fail;
17151 }
17152 }
17153 {
17154 PyThreadState* __tstate = wxPyBeginAllowThreads();
17155 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17156
17157 wxPyEndAllowThreads(__tstate);
17158 if (PyErr_Occurred()) SWIG_fail;
17159 }
17160 {
17161 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17162 }
17163 return resultobj;
17164 fail:
17165 return NULL;
17166 }
17167
17168
17169 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17170 PyObject *resultobj;
17171 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17172 wxString *arg2 = 0 ;
17173 bool result;
17174 bool temp2 = false ;
17175 PyObject * obj0 = 0 ;
17176 PyObject * obj1 = 0 ;
17177 char *kwnames[] = {
17178 (char *) "self",(char *) "name", NULL
17179 };
17180
17181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17183 if (SWIG_arg_fail(1)) SWIG_fail;
17184 {
17185 arg2 = wxString_in_helper(obj1);
17186 if (arg2 == NULL) SWIG_fail;
17187 temp2 = true;
17188 }
17189 {
17190 PyThreadState* __tstate = wxPyBeginAllowThreads();
17191 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17192
17193 wxPyEndAllowThreads(__tstate);
17194 if (PyErr_Occurred()) SWIG_fail;
17195 }
17196 {
17197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17198 }
17199 {
17200 if (temp2)
17201 delete arg2;
17202 }
17203 return resultobj;
17204 fail:
17205 {
17206 if (temp2)
17207 delete arg2;
17208 }
17209 return NULL;
17210 }
17211
17212
17213 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17214 PyObject *resultobj;
17215 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17216 wxString *arg2 = 0 ;
17217 bool result;
17218 bool temp2 = false ;
17219 PyObject * obj0 = 0 ;
17220 PyObject * obj1 = 0 ;
17221 char *kwnames[] = {
17222 (char *) "self",(char *) "name", NULL
17223 };
17224
17225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17227 if (SWIG_arg_fail(1)) SWIG_fail;
17228 {
17229 arg2 = wxString_in_helper(obj1);
17230 if (arg2 == NULL) SWIG_fail;
17231 temp2 = true;
17232 }
17233 {
17234 PyThreadState* __tstate = wxPyBeginAllowThreads();
17235 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17236
17237 wxPyEndAllowThreads(__tstate);
17238 if (PyErr_Occurred()) SWIG_fail;
17239 }
17240 {
17241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17242 }
17243 {
17244 if (temp2)
17245 delete arg2;
17246 }
17247 return resultobj;
17248 fail:
17249 {
17250 if (temp2)
17251 delete arg2;
17252 }
17253 return NULL;
17254 }
17255
17256
17257 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17258 PyObject *resultobj;
17259 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17260 wxString *arg2 = 0 ;
17261 bool result;
17262 bool temp2 = false ;
17263 PyObject * obj0 = 0 ;
17264 PyObject * obj1 = 0 ;
17265 char *kwnames[] = {
17266 (char *) "self",(char *) "name", NULL
17267 };
17268
17269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17271 if (SWIG_arg_fail(1)) SWIG_fail;
17272 {
17273 arg2 = wxString_in_helper(obj1);
17274 if (arg2 == NULL) SWIG_fail;
17275 temp2 = true;
17276 }
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17280
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 {
17288 if (temp2)
17289 delete arg2;
17290 }
17291 return resultobj;
17292 fail:
17293 {
17294 if (temp2)
17295 delete arg2;
17296 }
17297 return NULL;
17298 }
17299
17300
17301 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17302 PyObject *resultobj;
17303 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17304 wxString *arg2 = 0 ;
17305 wxConfigBase::EntryType result;
17306 bool temp2 = false ;
17307 PyObject * obj0 = 0 ;
17308 PyObject * obj1 = 0 ;
17309 char *kwnames[] = {
17310 (char *) "self",(char *) "name", NULL
17311 };
17312
17313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17315 if (SWIG_arg_fail(1)) SWIG_fail;
17316 {
17317 arg2 = wxString_in_helper(obj1);
17318 if (arg2 == NULL) SWIG_fail;
17319 temp2 = true;
17320 }
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17324
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 resultobj = SWIG_From_int((result));
17329 {
17330 if (temp2)
17331 delete arg2;
17332 }
17333 return resultobj;
17334 fail:
17335 {
17336 if (temp2)
17337 delete arg2;
17338 }
17339 return NULL;
17340 }
17341
17342
17343 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17344 PyObject *resultobj;
17345 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17346 wxString *arg2 = 0 ;
17347 wxString const &arg3_defvalue = wxPyEmptyString ;
17348 wxString *arg3 = (wxString *) &arg3_defvalue ;
17349 wxString result;
17350 bool temp2 = false ;
17351 bool temp3 = false ;
17352 PyObject * obj0 = 0 ;
17353 PyObject * obj1 = 0 ;
17354 PyObject * obj2 = 0 ;
17355 char *kwnames[] = {
17356 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17357 };
17358
17359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17361 if (SWIG_arg_fail(1)) SWIG_fail;
17362 {
17363 arg2 = wxString_in_helper(obj1);
17364 if (arg2 == NULL) SWIG_fail;
17365 temp2 = true;
17366 }
17367 if (obj2) {
17368 {
17369 arg3 = wxString_in_helper(obj2);
17370 if (arg3 == NULL) SWIG_fail;
17371 temp3 = true;
17372 }
17373 }
17374 {
17375 PyThreadState* __tstate = wxPyBeginAllowThreads();
17376 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17377
17378 wxPyEndAllowThreads(__tstate);
17379 if (PyErr_Occurred()) SWIG_fail;
17380 }
17381 {
17382 #if wxUSE_UNICODE
17383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17384 #else
17385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17386 #endif
17387 }
17388 {
17389 if (temp2)
17390 delete arg2;
17391 }
17392 {
17393 if (temp3)
17394 delete arg3;
17395 }
17396 return resultobj;
17397 fail:
17398 {
17399 if (temp2)
17400 delete arg2;
17401 }
17402 {
17403 if (temp3)
17404 delete arg3;
17405 }
17406 return NULL;
17407 }
17408
17409
17410 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17411 PyObject *resultobj;
17412 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17413 wxString *arg2 = 0 ;
17414 long arg3 = (long) 0 ;
17415 long result;
17416 bool temp2 = false ;
17417 PyObject * obj0 = 0 ;
17418 PyObject * obj1 = 0 ;
17419 PyObject * obj2 = 0 ;
17420 char *kwnames[] = {
17421 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17422 };
17423
17424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17426 if (SWIG_arg_fail(1)) SWIG_fail;
17427 {
17428 arg2 = wxString_in_helper(obj1);
17429 if (arg2 == NULL) SWIG_fail;
17430 temp2 = true;
17431 }
17432 if (obj2) {
17433 {
17434 arg3 = (long)(SWIG_As_long(obj2));
17435 if (SWIG_arg_fail(3)) SWIG_fail;
17436 }
17437 }
17438 {
17439 PyThreadState* __tstate = wxPyBeginAllowThreads();
17440 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17441
17442 wxPyEndAllowThreads(__tstate);
17443 if (PyErr_Occurred()) SWIG_fail;
17444 }
17445 {
17446 resultobj = SWIG_From_long((long)(result));
17447 }
17448 {
17449 if (temp2)
17450 delete arg2;
17451 }
17452 return resultobj;
17453 fail:
17454 {
17455 if (temp2)
17456 delete arg2;
17457 }
17458 return NULL;
17459 }
17460
17461
17462 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17463 PyObject *resultobj;
17464 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17465 wxString *arg2 = 0 ;
17466 double arg3 = (double) 0.0 ;
17467 double result;
17468 bool temp2 = false ;
17469 PyObject * obj0 = 0 ;
17470 PyObject * obj1 = 0 ;
17471 PyObject * obj2 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 arg2 = wxString_in_helper(obj1);
17481 if (arg2 == NULL) SWIG_fail;
17482 temp2 = true;
17483 }
17484 if (obj2) {
17485 {
17486 arg3 = (double)(SWIG_As_double(obj2));
17487 if (SWIG_arg_fail(3)) SWIG_fail;
17488 }
17489 }
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17493
17494 wxPyEndAllowThreads(__tstate);
17495 if (PyErr_Occurred()) SWIG_fail;
17496 }
17497 {
17498 resultobj = SWIG_From_double((double)(result));
17499 }
17500 {
17501 if (temp2)
17502 delete arg2;
17503 }
17504 return resultobj;
17505 fail:
17506 {
17507 if (temp2)
17508 delete arg2;
17509 }
17510 return NULL;
17511 }
17512
17513
17514 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17515 PyObject *resultobj;
17516 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17517 wxString *arg2 = 0 ;
17518 bool arg3 = (bool) false ;
17519 bool result;
17520 bool temp2 = false ;
17521 PyObject * obj0 = 0 ;
17522 PyObject * obj1 = 0 ;
17523 PyObject * obj2 = 0 ;
17524 char *kwnames[] = {
17525 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17526 };
17527
17528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17530 if (SWIG_arg_fail(1)) SWIG_fail;
17531 {
17532 arg2 = wxString_in_helper(obj1);
17533 if (arg2 == NULL) SWIG_fail;
17534 temp2 = true;
17535 }
17536 if (obj2) {
17537 {
17538 arg3 = (bool)(SWIG_As_bool(obj2));
17539 if (SWIG_arg_fail(3)) SWIG_fail;
17540 }
17541 }
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17545
17546 wxPyEndAllowThreads(__tstate);
17547 if (PyErr_Occurred()) SWIG_fail;
17548 }
17549 {
17550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17551 }
17552 {
17553 if (temp2)
17554 delete arg2;
17555 }
17556 return resultobj;
17557 fail:
17558 {
17559 if (temp2)
17560 delete arg2;
17561 }
17562 return NULL;
17563 }
17564
17565
17566 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17567 PyObject *resultobj;
17568 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17569 wxString *arg2 = 0 ;
17570 wxString *arg3 = 0 ;
17571 bool result;
17572 bool temp2 = false ;
17573 bool temp3 = false ;
17574 PyObject * obj0 = 0 ;
17575 PyObject * obj1 = 0 ;
17576 PyObject * obj2 = 0 ;
17577 char *kwnames[] = {
17578 (char *) "self",(char *) "key",(char *) "value", NULL
17579 };
17580
17581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17583 if (SWIG_arg_fail(1)) SWIG_fail;
17584 {
17585 arg2 = wxString_in_helper(obj1);
17586 if (arg2 == NULL) SWIG_fail;
17587 temp2 = true;
17588 }
17589 {
17590 arg3 = wxString_in_helper(obj2);
17591 if (arg3 == NULL) SWIG_fail;
17592 temp3 = true;
17593 }
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 {
17605 if (temp2)
17606 delete arg2;
17607 }
17608 {
17609 if (temp3)
17610 delete arg3;
17611 }
17612 return resultobj;
17613 fail:
17614 {
17615 if (temp2)
17616 delete arg2;
17617 }
17618 {
17619 if (temp3)
17620 delete arg3;
17621 }
17622 return NULL;
17623 }
17624
17625
17626 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj;
17628 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17629 wxString *arg2 = 0 ;
17630 long arg3 ;
17631 bool result;
17632 bool temp2 = false ;
17633 PyObject * obj0 = 0 ;
17634 PyObject * obj1 = 0 ;
17635 PyObject * obj2 = 0 ;
17636 char *kwnames[] = {
17637 (char *) "self",(char *) "key",(char *) "value", NULL
17638 };
17639
17640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 {
17644 arg2 = wxString_in_helper(obj1);
17645 if (arg2 == NULL) SWIG_fail;
17646 temp2 = true;
17647 }
17648 {
17649 arg3 = (long)(SWIG_As_long(obj2));
17650 if (SWIG_arg_fail(3)) SWIG_fail;
17651 }
17652 {
17653 PyThreadState* __tstate = wxPyBeginAllowThreads();
17654 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17655
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 {
17660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17661 }
17662 {
17663 if (temp2)
17664 delete arg2;
17665 }
17666 return resultobj;
17667 fail:
17668 {
17669 if (temp2)
17670 delete arg2;
17671 }
17672 return NULL;
17673 }
17674
17675
17676 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj;
17678 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17679 wxString *arg2 = 0 ;
17680 double arg3 ;
17681 bool result;
17682 bool temp2 = false ;
17683 PyObject * obj0 = 0 ;
17684 PyObject * obj1 = 0 ;
17685 PyObject * obj2 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self",(char *) "key",(char *) "value", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 {
17694 arg2 = wxString_in_helper(obj1);
17695 if (arg2 == NULL) SWIG_fail;
17696 temp2 = true;
17697 }
17698 {
17699 arg3 = (double)(SWIG_As_double(obj2));
17700 if (SWIG_arg_fail(3)) SWIG_fail;
17701 }
17702 {
17703 PyThreadState* __tstate = wxPyBeginAllowThreads();
17704 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17705
17706 wxPyEndAllowThreads(__tstate);
17707 if (PyErr_Occurred()) SWIG_fail;
17708 }
17709 {
17710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17711 }
17712 {
17713 if (temp2)
17714 delete arg2;
17715 }
17716 return resultobj;
17717 fail:
17718 {
17719 if (temp2)
17720 delete arg2;
17721 }
17722 return NULL;
17723 }
17724
17725
17726 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17727 PyObject *resultobj;
17728 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17729 wxString *arg2 = 0 ;
17730 bool arg3 ;
17731 bool result;
17732 bool temp2 = false ;
17733 PyObject * obj0 = 0 ;
17734 PyObject * obj1 = 0 ;
17735 PyObject * obj2 = 0 ;
17736 char *kwnames[] = {
17737 (char *) "self",(char *) "key",(char *) "value", NULL
17738 };
17739
17740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17742 if (SWIG_arg_fail(1)) SWIG_fail;
17743 {
17744 arg2 = wxString_in_helper(obj1);
17745 if (arg2 == NULL) SWIG_fail;
17746 temp2 = true;
17747 }
17748 {
17749 arg3 = (bool)(SWIG_As_bool(obj2));
17750 if (SWIG_arg_fail(3)) SWIG_fail;
17751 }
17752 {
17753 PyThreadState* __tstate = wxPyBeginAllowThreads();
17754 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17755
17756 wxPyEndAllowThreads(__tstate);
17757 if (PyErr_Occurred()) SWIG_fail;
17758 }
17759 {
17760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17761 }
17762 {
17763 if (temp2)
17764 delete arg2;
17765 }
17766 return resultobj;
17767 fail:
17768 {
17769 if (temp2)
17770 delete arg2;
17771 }
17772 return NULL;
17773 }
17774
17775
17776 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17777 PyObject *resultobj;
17778 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17779 bool arg2 = (bool) false ;
17780 bool result;
17781 PyObject * obj0 = 0 ;
17782 PyObject * obj1 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self",(char *) "currentOnly", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 if (obj1) {
17791 {
17792 arg2 = (bool)(SWIG_As_bool(obj1));
17793 if (SWIG_arg_fail(2)) SWIG_fail;
17794 }
17795 }
17796 {
17797 PyThreadState* __tstate = wxPyBeginAllowThreads();
17798 result = (bool)(arg1)->Flush(arg2);
17799
17800 wxPyEndAllowThreads(__tstate);
17801 if (PyErr_Occurred()) SWIG_fail;
17802 }
17803 {
17804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17805 }
17806 return resultobj;
17807 fail:
17808 return NULL;
17809 }
17810
17811
17812 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17813 PyObject *resultobj;
17814 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17815 wxString *arg2 = 0 ;
17816 wxString *arg3 = 0 ;
17817 bool result;
17818 bool temp2 = false ;
17819 bool temp3 = false ;
17820 PyObject * obj0 = 0 ;
17821 PyObject * obj1 = 0 ;
17822 PyObject * obj2 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 {
17831 arg2 = wxString_in_helper(obj1);
17832 if (arg2 == NULL) SWIG_fail;
17833 temp2 = true;
17834 }
17835 {
17836 arg3 = wxString_in_helper(obj2);
17837 if (arg3 == NULL) SWIG_fail;
17838 temp3 = true;
17839 }
17840 {
17841 PyThreadState* __tstate = wxPyBeginAllowThreads();
17842 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17843
17844 wxPyEndAllowThreads(__tstate);
17845 if (PyErr_Occurred()) SWIG_fail;
17846 }
17847 {
17848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17849 }
17850 {
17851 if (temp2)
17852 delete arg2;
17853 }
17854 {
17855 if (temp3)
17856 delete arg3;
17857 }
17858 return resultobj;
17859 fail:
17860 {
17861 if (temp2)
17862 delete arg2;
17863 }
17864 {
17865 if (temp3)
17866 delete arg3;
17867 }
17868 return NULL;
17869 }
17870
17871
17872 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj;
17874 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17875 wxString *arg2 = 0 ;
17876 wxString *arg3 = 0 ;
17877 bool result;
17878 bool temp2 = false ;
17879 bool temp3 = false ;
17880 PyObject * obj0 = 0 ;
17881 PyObject * obj1 = 0 ;
17882 PyObject * obj2 = 0 ;
17883 char *kwnames[] = {
17884 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17885 };
17886
17887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17889 if (SWIG_arg_fail(1)) SWIG_fail;
17890 {
17891 arg2 = wxString_in_helper(obj1);
17892 if (arg2 == NULL) SWIG_fail;
17893 temp2 = true;
17894 }
17895 {
17896 arg3 = wxString_in_helper(obj2);
17897 if (arg3 == NULL) SWIG_fail;
17898 temp3 = true;
17899 }
17900 {
17901 PyThreadState* __tstate = wxPyBeginAllowThreads();
17902 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17903
17904 wxPyEndAllowThreads(__tstate);
17905 if (PyErr_Occurred()) SWIG_fail;
17906 }
17907 {
17908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17909 }
17910 {
17911 if (temp2)
17912 delete arg2;
17913 }
17914 {
17915 if (temp3)
17916 delete arg3;
17917 }
17918 return resultobj;
17919 fail:
17920 {
17921 if (temp2)
17922 delete arg2;
17923 }
17924 {
17925 if (temp3)
17926 delete arg3;
17927 }
17928 return NULL;
17929 }
17930
17931
17932 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17933 PyObject *resultobj;
17934 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17935 wxString *arg2 = 0 ;
17936 bool arg3 = (bool) true ;
17937 bool result;
17938 bool temp2 = false ;
17939 PyObject * obj0 = 0 ;
17940 PyObject * obj1 = 0 ;
17941 PyObject * obj2 = 0 ;
17942 char *kwnames[] = {
17943 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17944 };
17945
17946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17948 if (SWIG_arg_fail(1)) SWIG_fail;
17949 {
17950 arg2 = wxString_in_helper(obj1);
17951 if (arg2 == NULL) SWIG_fail;
17952 temp2 = true;
17953 }
17954 if (obj2) {
17955 {
17956 arg3 = (bool)(SWIG_As_bool(obj2));
17957 if (SWIG_arg_fail(3)) SWIG_fail;
17958 }
17959 }
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17963
17964 wxPyEndAllowThreads(__tstate);
17965 if (PyErr_Occurred()) SWIG_fail;
17966 }
17967 {
17968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17969 }
17970 {
17971 if (temp2)
17972 delete arg2;
17973 }
17974 return resultobj;
17975 fail:
17976 {
17977 if (temp2)
17978 delete arg2;
17979 }
17980 return NULL;
17981 }
17982
17983
17984 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17985 PyObject *resultobj;
17986 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17987 wxString *arg2 = 0 ;
17988 bool result;
17989 bool temp2 = false ;
17990 PyObject * obj0 = 0 ;
17991 PyObject * obj1 = 0 ;
17992 char *kwnames[] = {
17993 (char *) "self",(char *) "key", NULL
17994 };
17995
17996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17998 if (SWIG_arg_fail(1)) SWIG_fail;
17999 {
18000 arg2 = wxString_in_helper(obj1);
18001 if (arg2 == NULL) SWIG_fail;
18002 temp2 = true;
18003 }
18004 {
18005 PyThreadState* __tstate = wxPyBeginAllowThreads();
18006 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18007
18008 wxPyEndAllowThreads(__tstate);
18009 if (PyErr_Occurred()) SWIG_fail;
18010 }
18011 {
18012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18013 }
18014 {
18015 if (temp2)
18016 delete arg2;
18017 }
18018 return resultobj;
18019 fail:
18020 {
18021 if (temp2)
18022 delete arg2;
18023 }
18024 return NULL;
18025 }
18026
18027
18028 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18029 PyObject *resultobj;
18030 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18031 bool result;
18032 PyObject * obj0 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (bool)(arg1)->DeleteAll();
18043
18044 wxPyEndAllowThreads(__tstate);
18045 if (PyErr_Occurred()) SWIG_fail;
18046 }
18047 {
18048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18049 }
18050 return resultobj;
18051 fail:
18052 return NULL;
18053 }
18054
18055
18056 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18057 PyObject *resultobj;
18058 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18059 bool arg2 = (bool) true ;
18060 PyObject * obj0 = 0 ;
18061 PyObject * obj1 = 0 ;
18062 char *kwnames[] = {
18063 (char *) "self",(char *) "doIt", NULL
18064 };
18065
18066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18068 if (SWIG_arg_fail(1)) SWIG_fail;
18069 if (obj1) {
18070 {
18071 arg2 = (bool)(SWIG_As_bool(obj1));
18072 if (SWIG_arg_fail(2)) SWIG_fail;
18073 }
18074 }
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 (arg1)->SetExpandEnvVars(arg2);
18078
18079 wxPyEndAllowThreads(__tstate);
18080 if (PyErr_Occurred()) SWIG_fail;
18081 }
18082 Py_INCREF(Py_None); resultobj = Py_None;
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18092 bool result;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 {
18109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18110 }
18111 return resultobj;
18112 fail:
18113 return NULL;
18114 }
18115
18116
18117 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18118 PyObject *resultobj;
18119 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18120 bool arg2 = (bool) true ;
18121 PyObject * obj0 = 0 ;
18122 PyObject * obj1 = 0 ;
18123 char *kwnames[] = {
18124 (char *) "self",(char *) "doIt", NULL
18125 };
18126
18127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18129 if (SWIG_arg_fail(1)) SWIG_fail;
18130 if (obj1) {
18131 {
18132 arg2 = (bool)(SWIG_As_bool(obj1));
18133 if (SWIG_arg_fail(2)) SWIG_fail;
18134 }
18135 }
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 (arg1)->SetRecordDefaults(arg2);
18139
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 Py_INCREF(Py_None); resultobj = Py_None;
18144 return resultobj;
18145 fail:
18146 return NULL;
18147 }
18148
18149
18150 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18151 PyObject *resultobj;
18152 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18153 bool result;
18154 PyObject * obj0 = 0 ;
18155 char *kwnames[] = {
18156 (char *) "self", NULL
18157 };
18158
18159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18161 if (SWIG_arg_fail(1)) SWIG_fail;
18162 {
18163 PyThreadState* __tstate = wxPyBeginAllowThreads();
18164 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18165
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 {
18170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18171 }
18172 return resultobj;
18173 fail:
18174 return NULL;
18175 }
18176
18177
18178 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18179 PyObject *resultobj;
18180 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18181 wxString *arg2 = 0 ;
18182 wxString result;
18183 bool temp2 = false ;
18184 PyObject * obj0 = 0 ;
18185 PyObject * obj1 = 0 ;
18186 char *kwnames[] = {
18187 (char *) "self",(char *) "str", NULL
18188 };
18189
18190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18192 if (SWIG_arg_fail(1)) SWIG_fail;
18193 {
18194 arg2 = wxString_in_helper(obj1);
18195 if (arg2 == NULL) SWIG_fail;
18196 temp2 = true;
18197 }
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18201
18202 wxPyEndAllowThreads(__tstate);
18203 if (PyErr_Occurred()) SWIG_fail;
18204 }
18205 {
18206 #if wxUSE_UNICODE
18207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18208 #else
18209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18210 #endif
18211 }
18212 {
18213 if (temp2)
18214 delete arg2;
18215 }
18216 return resultobj;
18217 fail:
18218 {
18219 if (temp2)
18220 delete arg2;
18221 }
18222 return NULL;
18223 }
18224
18225
18226 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18227 PyObject *resultobj;
18228 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18229 wxString result;
18230 PyObject * obj0 = 0 ;
18231 char *kwnames[] = {
18232 (char *) "self", NULL
18233 };
18234
18235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18237 if (SWIG_arg_fail(1)) SWIG_fail;
18238 {
18239 PyThreadState* __tstate = wxPyBeginAllowThreads();
18240 result = ((wxConfigBase const *)arg1)->GetAppName();
18241
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 {
18246 #if wxUSE_UNICODE
18247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18248 #else
18249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18250 #endif
18251 }
18252 return resultobj;
18253 fail:
18254 return NULL;
18255 }
18256
18257
18258 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18259 PyObject *resultobj;
18260 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18261 wxString result;
18262 PyObject * obj0 = 0 ;
18263 char *kwnames[] = {
18264 (char *) "self", NULL
18265 };
18266
18267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18269 if (SWIG_arg_fail(1)) SWIG_fail;
18270 {
18271 PyThreadState* __tstate = wxPyBeginAllowThreads();
18272 result = ((wxConfigBase const *)arg1)->GetVendorName();
18273
18274 wxPyEndAllowThreads(__tstate);
18275 if (PyErr_Occurred()) SWIG_fail;
18276 }
18277 {
18278 #if wxUSE_UNICODE
18279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18280 #else
18281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18282 #endif
18283 }
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18291 PyObject *resultobj;
18292 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18293 wxString *arg2 = 0 ;
18294 bool temp2 = false ;
18295 PyObject * obj0 = 0 ;
18296 PyObject * obj1 = 0 ;
18297 char *kwnames[] = {
18298 (char *) "self",(char *) "appName", NULL
18299 };
18300
18301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18303 if (SWIG_arg_fail(1)) SWIG_fail;
18304 {
18305 arg2 = wxString_in_helper(obj1);
18306 if (arg2 == NULL) SWIG_fail;
18307 temp2 = true;
18308 }
18309 {
18310 PyThreadState* __tstate = wxPyBeginAllowThreads();
18311 (arg1)->SetAppName((wxString const &)*arg2);
18312
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 Py_INCREF(Py_None); resultobj = Py_None;
18317 {
18318 if (temp2)
18319 delete arg2;
18320 }
18321 return resultobj;
18322 fail:
18323 {
18324 if (temp2)
18325 delete arg2;
18326 }
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18334 wxString *arg2 = 0 ;
18335 bool temp2 = false ;
18336 PyObject * obj0 = 0 ;
18337 PyObject * obj1 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "self",(char *) "vendorName", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 {
18346 arg2 = wxString_in_helper(obj1);
18347 if (arg2 == NULL) SWIG_fail;
18348 temp2 = true;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 (arg1)->SetVendorName((wxString const &)*arg2);
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 Py_INCREF(Py_None); resultobj = Py_None;
18358 {
18359 if (temp2)
18360 delete arg2;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 return NULL;
18369 }
18370
18371
18372 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj;
18374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18375 long arg2 ;
18376 PyObject * obj0 = 0 ;
18377 PyObject * obj1 = 0 ;
18378 char *kwnames[] = {
18379 (char *) "self",(char *) "style", NULL
18380 };
18381
18382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18384 if (SWIG_arg_fail(1)) SWIG_fail;
18385 {
18386 arg2 = (long)(SWIG_As_long(obj1));
18387 if (SWIG_arg_fail(2)) SWIG_fail;
18388 }
18389 {
18390 PyThreadState* __tstate = wxPyBeginAllowThreads();
18391 (arg1)->SetStyle(arg2);
18392
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 Py_INCREF(Py_None); resultobj = Py_None;
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj;
18405 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18406 long result;
18407 PyObject * obj0 = 0 ;
18408 char *kwnames[] = {
18409 (char *) "self", NULL
18410 };
18411
18412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18414 if (SWIG_arg_fail(1)) SWIG_fail;
18415 {
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18418
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 {
18423 resultobj = SWIG_From_long((long)(result));
18424 }
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18432 PyObject *obj;
18433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18434 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18435 Py_INCREF(obj);
18436 return Py_BuildValue((char *)"");
18437 }
18438 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18439 PyObject *resultobj;
18440 wxString const &arg1_defvalue = wxPyEmptyString ;
18441 wxString *arg1 = (wxString *) &arg1_defvalue ;
18442 wxString const &arg2_defvalue = wxPyEmptyString ;
18443 wxString *arg2 = (wxString *) &arg2_defvalue ;
18444 wxString const &arg3_defvalue = wxPyEmptyString ;
18445 wxString *arg3 = (wxString *) &arg3_defvalue ;
18446 wxString const &arg4_defvalue = wxPyEmptyString ;
18447 wxString *arg4 = (wxString *) &arg4_defvalue ;
18448 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18449 wxConfig *result;
18450 bool temp1 = false ;
18451 bool temp2 = false ;
18452 bool temp3 = false ;
18453 bool temp4 = false ;
18454 PyObject * obj0 = 0 ;
18455 PyObject * obj1 = 0 ;
18456 PyObject * obj2 = 0 ;
18457 PyObject * obj3 = 0 ;
18458 PyObject * obj4 = 0 ;
18459 char *kwnames[] = {
18460 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18461 };
18462
18463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18464 if (obj0) {
18465 {
18466 arg1 = wxString_in_helper(obj0);
18467 if (arg1 == NULL) SWIG_fail;
18468 temp1 = true;
18469 }
18470 }
18471 if (obj1) {
18472 {
18473 arg2 = wxString_in_helper(obj1);
18474 if (arg2 == NULL) SWIG_fail;
18475 temp2 = true;
18476 }
18477 }
18478 if (obj2) {
18479 {
18480 arg3 = wxString_in_helper(obj2);
18481 if (arg3 == NULL) SWIG_fail;
18482 temp3 = true;
18483 }
18484 }
18485 if (obj3) {
18486 {
18487 arg4 = wxString_in_helper(obj3);
18488 if (arg4 == NULL) SWIG_fail;
18489 temp4 = true;
18490 }
18491 }
18492 if (obj4) {
18493 {
18494 arg5 = (long)(SWIG_As_long(obj4));
18495 if (SWIG_arg_fail(5)) SWIG_fail;
18496 }
18497 }
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18501
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18506 {
18507 if (temp1)
18508 delete arg1;
18509 }
18510 {
18511 if (temp2)
18512 delete arg2;
18513 }
18514 {
18515 if (temp3)
18516 delete arg3;
18517 }
18518 {
18519 if (temp4)
18520 delete arg4;
18521 }
18522 return resultobj;
18523 fail:
18524 {
18525 if (temp1)
18526 delete arg1;
18527 }
18528 {
18529 if (temp2)
18530 delete arg2;
18531 }
18532 {
18533 if (temp3)
18534 delete arg3;
18535 }
18536 {
18537 if (temp4)
18538 delete arg4;
18539 }
18540 return NULL;
18541 }
18542
18543
18544 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18545 PyObject *resultobj;
18546 wxConfig *arg1 = (wxConfig *) 0 ;
18547 PyObject * obj0 = 0 ;
18548 char *kwnames[] = {
18549 (char *) "self", NULL
18550 };
18551
18552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18554 if (SWIG_arg_fail(1)) SWIG_fail;
18555 {
18556 PyThreadState* __tstate = wxPyBeginAllowThreads();
18557 delete arg1;
18558
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 Py_INCREF(Py_None); resultobj = Py_None;
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18570 PyObject *obj;
18571 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18572 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18573 Py_INCREF(obj);
18574 return Py_BuildValue((char *)"");
18575 }
18576 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj;
18578 wxString const &arg1_defvalue = wxPyEmptyString ;
18579 wxString *arg1 = (wxString *) &arg1_defvalue ;
18580 wxString const &arg2_defvalue = wxPyEmptyString ;
18581 wxString *arg2 = (wxString *) &arg2_defvalue ;
18582 wxString const &arg3_defvalue = wxPyEmptyString ;
18583 wxString *arg3 = (wxString *) &arg3_defvalue ;
18584 wxString const &arg4_defvalue = wxPyEmptyString ;
18585 wxString *arg4 = (wxString *) &arg4_defvalue ;
18586 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18587 wxFileConfig *result;
18588 bool temp1 = false ;
18589 bool temp2 = false ;
18590 bool temp3 = false ;
18591 bool temp4 = false ;
18592 PyObject * obj0 = 0 ;
18593 PyObject * obj1 = 0 ;
18594 PyObject * obj2 = 0 ;
18595 PyObject * obj3 = 0 ;
18596 PyObject * obj4 = 0 ;
18597 char *kwnames[] = {
18598 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18599 };
18600
18601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18602 if (obj0) {
18603 {
18604 arg1 = wxString_in_helper(obj0);
18605 if (arg1 == NULL) SWIG_fail;
18606 temp1 = true;
18607 }
18608 }
18609 if (obj1) {
18610 {
18611 arg2 = wxString_in_helper(obj1);
18612 if (arg2 == NULL) SWIG_fail;
18613 temp2 = true;
18614 }
18615 }
18616 if (obj2) {
18617 {
18618 arg3 = wxString_in_helper(obj2);
18619 if (arg3 == NULL) SWIG_fail;
18620 temp3 = true;
18621 }
18622 }
18623 if (obj3) {
18624 {
18625 arg4 = wxString_in_helper(obj3);
18626 if (arg4 == NULL) SWIG_fail;
18627 temp4 = true;
18628 }
18629 }
18630 if (obj4) {
18631 {
18632 arg5 = (long)(SWIG_As_long(obj4));
18633 if (SWIG_arg_fail(5)) SWIG_fail;
18634 }
18635 }
18636 {
18637 PyThreadState* __tstate = wxPyBeginAllowThreads();
18638 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18639
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18644 {
18645 if (temp1)
18646 delete arg1;
18647 }
18648 {
18649 if (temp2)
18650 delete arg2;
18651 }
18652 {
18653 if (temp3)
18654 delete arg3;
18655 }
18656 {
18657 if (temp4)
18658 delete arg4;
18659 }
18660 return resultobj;
18661 fail:
18662 {
18663 if (temp1)
18664 delete arg1;
18665 }
18666 {
18667 if (temp2)
18668 delete arg2;
18669 }
18670 {
18671 if (temp3)
18672 delete arg3;
18673 }
18674 {
18675 if (temp4)
18676 delete arg4;
18677 }
18678 return NULL;
18679 }
18680
18681
18682 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18683 PyObject *resultobj;
18684 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18685 PyObject * obj0 = 0 ;
18686 char *kwnames[] = {
18687 (char *) "self", NULL
18688 };
18689
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18692 if (SWIG_arg_fail(1)) SWIG_fail;
18693 {
18694 PyThreadState* __tstate = wxPyBeginAllowThreads();
18695 delete arg1;
18696
18697 wxPyEndAllowThreads(__tstate);
18698 if (PyErr_Occurred()) SWIG_fail;
18699 }
18700 Py_INCREF(Py_None); resultobj = Py_None;
18701 return resultobj;
18702 fail:
18703 return NULL;
18704 }
18705
18706
18707 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18708 PyObject *obj;
18709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18710 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18711 Py_INCREF(obj);
18712 return Py_BuildValue((char *)"");
18713 }
18714 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18715 PyObject *resultobj;
18716 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18717 wxString *arg2 = 0 ;
18718 wxConfigPathChanger *result;
18719 bool temp2 = false ;
18720 PyObject * obj0 = 0 ;
18721 PyObject * obj1 = 0 ;
18722 char *kwnames[] = {
18723 (char *) "config",(char *) "entry", NULL
18724 };
18725
18726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18728 if (SWIG_arg_fail(1)) SWIG_fail;
18729 {
18730 arg2 = wxString_in_helper(obj1);
18731 if (arg2 == NULL) SWIG_fail;
18732 temp2 = true;
18733 }
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18737
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18742 {
18743 if (temp2)
18744 delete arg2;
18745 }
18746 return resultobj;
18747 fail:
18748 {
18749 if (temp2)
18750 delete arg2;
18751 }
18752 return NULL;
18753 }
18754
18755
18756 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18757 PyObject *resultobj;
18758 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18759 PyObject * obj0 = 0 ;
18760 char *kwnames[] = {
18761 (char *) "self", NULL
18762 };
18763
18764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18766 if (SWIG_arg_fail(1)) SWIG_fail;
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 delete arg1;
18770
18771 wxPyEndAllowThreads(__tstate);
18772 if (PyErr_Occurred()) SWIG_fail;
18773 }
18774 Py_INCREF(Py_None); resultobj = Py_None;
18775 return resultobj;
18776 fail:
18777 return NULL;
18778 }
18779
18780
18781 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18782 PyObject *resultobj;
18783 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18784 wxString *result;
18785 PyObject * obj0 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 {
18794 PyThreadState* __tstate = wxPyBeginAllowThreads();
18795 {
18796 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18797 result = (wxString *) &_result_ref;
18798 }
18799
18800 wxPyEndAllowThreads(__tstate);
18801 if (PyErr_Occurred()) SWIG_fail;
18802 }
18803 {
18804 #if wxUSE_UNICODE
18805 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18806 #else
18807 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18808 #endif
18809 }
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18817 PyObject *obj;
18818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18819 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18820 Py_INCREF(obj);
18821 return Py_BuildValue((char *)"");
18822 }
18823 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18824 PyObject *resultobj;
18825 wxString *arg1 = 0 ;
18826 wxString result;
18827 bool temp1 = false ;
18828 PyObject * obj0 = 0 ;
18829 char *kwnames[] = {
18830 (char *) "sz", NULL
18831 };
18832
18833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18834 {
18835 arg1 = wxString_in_helper(obj0);
18836 if (arg1 == NULL) SWIG_fail;
18837 temp1 = true;
18838 }
18839 {
18840 PyThreadState* __tstate = wxPyBeginAllowThreads();
18841 result = wxExpandEnvVars((wxString const &)*arg1);
18842
18843 wxPyEndAllowThreads(__tstate);
18844 if (PyErr_Occurred()) SWIG_fail;
18845 }
18846 {
18847 #if wxUSE_UNICODE
18848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18849 #else
18850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18851 #endif
18852 }
18853 {
18854 if (temp1)
18855 delete arg1;
18856 }
18857 return resultobj;
18858 fail:
18859 {
18860 if (temp1)
18861 delete arg1;
18862 }
18863 return NULL;
18864 }
18865
18866
18867 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18868 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18869 return 1;
18870 }
18871
18872
18873 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18874 PyObject *pyobj;
18875
18876 {
18877 #if wxUSE_UNICODE
18878 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18879 #else
18880 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18881 #endif
18882 }
18883 return pyobj;
18884 }
18885
18886
18887 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18888 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18889 return 1;
18890 }
18891
18892
18893 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18894 PyObject *pyobj;
18895
18896 {
18897 #if wxUSE_UNICODE
18898 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18899 #else
18900 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18901 #endif
18902 }
18903 return pyobj;
18904 }
18905
18906
18907 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18908 PyObject *resultobj;
18909 wxDateTime::Country arg1 ;
18910 PyObject * obj0 = 0 ;
18911 char *kwnames[] = {
18912 (char *) "country", NULL
18913 };
18914
18915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18916 {
18917 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 }
18920 {
18921 PyThreadState* __tstate = wxPyBeginAllowThreads();
18922 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18923
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 Py_INCREF(Py_None); resultobj = Py_None;
18928 return resultobj;
18929 fail:
18930 return NULL;
18931 }
18932
18933
18934 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18935 PyObject *resultobj;
18936 wxDateTime::Country result;
18937 char *kwnames[] = {
18938 NULL
18939 };
18940
18941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18942 {
18943 PyThreadState* __tstate = wxPyBeginAllowThreads();
18944 result = (wxDateTime::Country)wxDateTime::GetCountry();
18945
18946 wxPyEndAllowThreads(__tstate);
18947 if (PyErr_Occurred()) SWIG_fail;
18948 }
18949 resultobj = SWIG_From_int((result));
18950 return resultobj;
18951 fail:
18952 return NULL;
18953 }
18954
18955
18956 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18957 PyObject *resultobj;
18958 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18959 bool result;
18960 PyObject * obj0 = 0 ;
18961 char *kwnames[] = {
18962 (char *) "country", NULL
18963 };
18964
18965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18966 if (obj0) {
18967 {
18968 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18969 if (SWIG_arg_fail(1)) SWIG_fail;
18970 }
18971 }
18972 {
18973 PyThreadState* __tstate = wxPyBeginAllowThreads();
18974 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18975
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 {
18980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18981 }
18982 return resultobj;
18983 fail:
18984 return NULL;
18985 }
18986
18987
18988 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18989 PyObject *resultobj;
18990 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18991 int result;
18992 PyObject * obj0 = 0 ;
18993 char *kwnames[] = {
18994 (char *) "cal", NULL
18995 };
18996
18997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18998 if (obj0) {
18999 {
19000 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19001 if (SWIG_arg_fail(1)) SWIG_fail;
19002 }
19003 }
19004 {
19005 PyThreadState* __tstate = wxPyBeginAllowThreads();
19006 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19007
19008 wxPyEndAllowThreads(__tstate);
19009 if (PyErr_Occurred()) SWIG_fail;
19010 }
19011 {
19012 resultobj = SWIG_From_int((int)(result));
19013 }
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19021 PyObject *resultobj;
19022 int arg1 ;
19023 int result;
19024 PyObject * obj0 = 0 ;
19025 char *kwnames[] = {
19026 (char *) "year", NULL
19027 };
19028
19029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19030 {
19031 arg1 = (int)(SWIG_As_int(obj0));
19032 if (SWIG_arg_fail(1)) SWIG_fail;
19033 }
19034 {
19035 PyThreadState* __tstate = wxPyBeginAllowThreads();
19036 result = (int)wxDateTime::ConvertYearToBC(arg1);
19037
19038 wxPyEndAllowThreads(__tstate);
19039 if (PyErr_Occurred()) SWIG_fail;
19040 }
19041 {
19042 resultobj = SWIG_From_int((int)(result));
19043 }
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj;
19052 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19053 wxDateTime::Month result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "cal", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19060 if (obj0) {
19061 {
19062 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19063 if (SWIG_arg_fail(1)) SWIG_fail;
19064 }
19065 }
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19069
19070 wxPyEndAllowThreads(__tstate);
19071 if (PyErr_Occurred()) SWIG_fail;
19072 }
19073 resultobj = SWIG_From_int((result));
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 int arg1 = (int) wxDateTime::Inv_Year ;
19083 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19084 bool result;
19085 PyObject * obj0 = 0 ;
19086 PyObject * obj1 = 0 ;
19087 char *kwnames[] = {
19088 (char *) "year",(char *) "cal", NULL
19089 };
19090
19091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19092 if (obj0) {
19093 {
19094 arg1 = (int)(SWIG_As_int(obj0));
19095 if (SWIG_arg_fail(1)) SWIG_fail;
19096 }
19097 }
19098 if (obj1) {
19099 {
19100 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19101 if (SWIG_arg_fail(2)) SWIG_fail;
19102 }
19103 }
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19107
19108 wxPyEndAllowThreads(__tstate);
19109 if (PyErr_Occurred()) SWIG_fail;
19110 }
19111 {
19112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19113 }
19114 return resultobj;
19115 fail:
19116 return NULL;
19117 }
19118
19119
19120 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19121 PyObject *resultobj;
19122 int arg1 = (int) wxDateTime::Inv_Year ;
19123 int result;
19124 PyObject * obj0 = 0 ;
19125 char *kwnames[] = {
19126 (char *) "year", NULL
19127 };
19128
19129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19130 if (obj0) {
19131 {
19132 arg1 = (int)(SWIG_As_int(obj0));
19133 if (SWIG_arg_fail(1)) SWIG_fail;
19134 }
19135 }
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (int)wxDateTime::GetCentury(arg1);
19139
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 {
19144 resultobj = SWIG_From_int((int)(result));
19145 }
19146 return resultobj;
19147 fail:
19148 return NULL;
19149 }
19150
19151
19152 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19153 PyObject *resultobj;
19154 int arg1 ;
19155 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19156 int result;
19157 PyObject * obj0 = 0 ;
19158 PyObject * obj1 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "year",(char *) "cal", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19164 {
19165 arg1 = (int)(SWIG_As_int(obj0));
19166 if (SWIG_arg_fail(1)) SWIG_fail;
19167 }
19168 if (obj1) {
19169 {
19170 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19171 if (SWIG_arg_fail(2)) SWIG_fail;
19172 }
19173 }
19174 {
19175 PyThreadState* __tstate = wxPyBeginAllowThreads();
19176 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19177
19178 wxPyEndAllowThreads(__tstate);
19179 if (PyErr_Occurred()) SWIG_fail;
19180 }
19181 {
19182 resultobj = SWIG_From_int((int)(result));
19183 }
19184 return resultobj;
19185 fail:
19186 return NULL;
19187 }
19188
19189
19190 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19191 PyObject *resultobj;
19192 wxDateTime::Month arg1 ;
19193 int arg2 = (int) wxDateTime::Inv_Year ;
19194 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19195 int result;
19196 PyObject * obj0 = 0 ;
19197 PyObject * obj1 = 0 ;
19198 PyObject * obj2 = 0 ;
19199 char *kwnames[] = {
19200 (char *) "month",(char *) "year",(char *) "cal", NULL
19201 };
19202
19203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19204 {
19205 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19206 if (SWIG_arg_fail(1)) SWIG_fail;
19207 }
19208 if (obj1) {
19209 {
19210 arg2 = (int)(SWIG_As_int(obj1));
19211 if (SWIG_arg_fail(2)) SWIG_fail;
19212 }
19213 }
19214 if (obj2) {
19215 {
19216 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19217 if (SWIG_arg_fail(3)) SWIG_fail;
19218 }
19219 }
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = SWIG_From_int((int)(result));
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj;
19238 wxDateTime::Month arg1 ;
19239 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19240 wxString result;
19241 PyObject * obj0 = 0 ;
19242 PyObject * obj1 = 0 ;
19243 char *kwnames[] = {
19244 (char *) "month",(char *) "flags", NULL
19245 };
19246
19247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19248 {
19249 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19250 if (SWIG_arg_fail(1)) SWIG_fail;
19251 }
19252 if (obj1) {
19253 {
19254 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19255 if (SWIG_arg_fail(2)) SWIG_fail;
19256 }
19257 }
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19261
19262 wxPyEndAllowThreads(__tstate);
19263 if (PyErr_Occurred()) SWIG_fail;
19264 }
19265 {
19266 #if wxUSE_UNICODE
19267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19268 #else
19269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19270 #endif
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj;
19280 wxDateTime::WeekDay arg1 ;
19281 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19282 wxString result;
19283 PyObject * obj0 = 0 ;
19284 PyObject * obj1 = 0 ;
19285 char *kwnames[] = {
19286 (char *) "weekday",(char *) "flags", NULL
19287 };
19288
19289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19290 {
19291 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19292 if (SWIG_arg_fail(1)) SWIG_fail;
19293 }
19294 if (obj1) {
19295 {
19296 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19297 if (SWIG_arg_fail(2)) SWIG_fail;
19298 }
19299 }
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19303
19304 wxPyEndAllowThreads(__tstate);
19305 if (PyErr_Occurred()) SWIG_fail;
19306 }
19307 {
19308 #if wxUSE_UNICODE
19309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19310 #else
19311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19312 #endif
19313 }
19314 return resultobj;
19315 fail:
19316 return NULL;
19317 }
19318
19319
19320 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19321 PyObject *resultobj;
19322 PyObject *result;
19323 char *kwnames[] = {
19324 NULL
19325 };
19326
19327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (PyObject *)DateTime_GetAmPmStrings();
19331
19332 wxPyEndAllowThreads(__tstate);
19333 if (PyErr_Occurred()) SWIG_fail;
19334 }
19335 resultobj = result;
19336 return resultobj;
19337 fail:
19338 return NULL;
19339 }
19340
19341
19342 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19343 PyObject *resultobj;
19344 int arg1 = (int) wxDateTime::Inv_Year ;
19345 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19346 bool result;
19347 PyObject * obj0 = 0 ;
19348 PyObject * obj1 = 0 ;
19349 char *kwnames[] = {
19350 (char *) "year",(char *) "country", NULL
19351 };
19352
19353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19354 if (obj0) {
19355 {
19356 arg1 = (int)(SWIG_As_int(obj0));
19357 if (SWIG_arg_fail(1)) SWIG_fail;
19358 }
19359 }
19360 if (obj1) {
19361 {
19362 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19363 if (SWIG_arg_fail(2)) SWIG_fail;
19364 }
19365 }
19366 {
19367 PyThreadState* __tstate = wxPyBeginAllowThreads();
19368 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19369
19370 wxPyEndAllowThreads(__tstate);
19371 if (PyErr_Occurred()) SWIG_fail;
19372 }
19373 {
19374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19375 }
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19383 PyObject *resultobj;
19384 int arg1 = (int) wxDateTime::Inv_Year ;
19385 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19386 wxDateTime result;
19387 PyObject * obj0 = 0 ;
19388 PyObject * obj1 = 0 ;
19389 char *kwnames[] = {
19390 (char *) "year",(char *) "country", NULL
19391 };
19392
19393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19394 if (obj0) {
19395 {
19396 arg1 = (int)(SWIG_As_int(obj0));
19397 if (SWIG_arg_fail(1)) SWIG_fail;
19398 }
19399 }
19400 if (obj1) {
19401 {
19402 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19403 if (SWIG_arg_fail(2)) SWIG_fail;
19404 }
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19409
19410 wxPyEndAllowThreads(__tstate);
19411 if (PyErr_Occurred()) SWIG_fail;
19412 }
19413 {
19414 wxDateTime * resultptr;
19415 resultptr = new wxDateTime((wxDateTime &)(result));
19416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19417 }
19418 return resultobj;
19419 fail:
19420 return NULL;
19421 }
19422
19423
19424 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19425 PyObject *resultobj;
19426 int arg1 = (int) wxDateTime::Inv_Year ;
19427 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19428 wxDateTime result;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "year",(char *) "country", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19436 if (obj0) {
19437 {
19438 arg1 = (int)(SWIG_As_int(obj0));
19439 if (SWIG_arg_fail(1)) SWIG_fail;
19440 }
19441 }
19442 if (obj1) {
19443 {
19444 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19445 if (SWIG_arg_fail(2)) SWIG_fail;
19446 }
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19451
19452 wxPyEndAllowThreads(__tstate);
19453 if (PyErr_Occurred()) SWIG_fail;
19454 }
19455 {
19456 wxDateTime * resultptr;
19457 resultptr = new wxDateTime((wxDateTime &)(result));
19458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19459 }
19460 return resultobj;
19461 fail:
19462 return NULL;
19463 }
19464
19465
19466 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj;
19468 wxDateTime result;
19469 char *kwnames[] = {
19470 NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = wxDateTime::Now();
19477
19478 wxPyEndAllowThreads(__tstate);
19479 if (PyErr_Occurred()) SWIG_fail;
19480 }
19481 {
19482 wxDateTime * resultptr;
19483 resultptr = new wxDateTime((wxDateTime &)(result));
19484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19485 }
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19493 PyObject *resultobj;
19494 wxDateTime result;
19495 char *kwnames[] = {
19496 NULL
19497 };
19498
19499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 result = wxDateTime::UNow();
19503
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 {
19508 wxDateTime * resultptr;
19509 resultptr = new wxDateTime((wxDateTime &)(result));
19510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19511 }
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj;
19520 wxDateTime result;
19521 char *kwnames[] = {
19522 NULL
19523 };
19524
19525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19526 {
19527 PyThreadState* __tstate = wxPyBeginAllowThreads();
19528 result = wxDateTime::Today();
19529
19530 wxPyEndAllowThreads(__tstate);
19531 if (PyErr_Occurred()) SWIG_fail;
19532 }
19533 {
19534 wxDateTime * resultptr;
19535 resultptr = new wxDateTime((wxDateTime &)(result));
19536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19537 }
19538 return resultobj;
19539 fail:
19540 return NULL;
19541 }
19542
19543
19544 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19545 PyObject *resultobj;
19546 wxDateTime *result;
19547 char *kwnames[] = {
19548 NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19552 {
19553 PyThreadState* __tstate = wxPyBeginAllowThreads();
19554 result = (wxDateTime *)new wxDateTime();
19555
19556 wxPyEndAllowThreads(__tstate);
19557 if (PyErr_Occurred()) SWIG_fail;
19558 }
19559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19560 return resultobj;
19561 fail:
19562 return NULL;
19563 }
19564
19565
19566 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19567 PyObject *resultobj;
19568 time_t arg1 ;
19569 wxDateTime *result;
19570 PyObject * obj0 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "timet", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19576 {
19577 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19578 if (SWIG_arg_fail(1)) SWIG_fail;
19579 }
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = (wxDateTime *)new wxDateTime(arg1);
19583
19584 wxPyEndAllowThreads(__tstate);
19585 if (PyErr_Occurred()) SWIG_fail;
19586 }
19587 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19588 return resultobj;
19589 fail:
19590 return NULL;
19591 }
19592
19593
19594 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19595 PyObject *resultobj;
19596 double arg1 ;
19597 wxDateTime *result;
19598 PyObject * obj0 = 0 ;
19599 char *kwnames[] = {
19600 (char *) "jdn", NULL
19601 };
19602
19603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19604 {
19605 arg1 = (double)(SWIG_As_double(obj0));
19606 if (SWIG_arg_fail(1)) SWIG_fail;
19607 }
19608 {
19609 PyThreadState* __tstate = wxPyBeginAllowThreads();
19610 result = (wxDateTime *)new wxDateTime(arg1);
19611
19612 wxPyEndAllowThreads(__tstate);
19613 if (PyErr_Occurred()) SWIG_fail;
19614 }
19615 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19616 return resultobj;
19617 fail:
19618 return NULL;
19619 }
19620
19621
19622 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19623 PyObject *resultobj;
19624 int arg1 ;
19625 int arg2 = (int) 0 ;
19626 int arg3 = (int) 0 ;
19627 int arg4 = (int) 0 ;
19628 wxDateTime *result;
19629 PyObject * obj0 = 0 ;
19630 PyObject * obj1 = 0 ;
19631 PyObject * obj2 = 0 ;
19632 PyObject * obj3 = 0 ;
19633 char *kwnames[] = {
19634 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19635 };
19636
19637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19638 {
19639 arg1 = (int)(SWIG_As_int(obj0));
19640 if (SWIG_arg_fail(1)) SWIG_fail;
19641 }
19642 if (obj1) {
19643 {
19644 arg2 = (int)(SWIG_As_int(obj1));
19645 if (SWIG_arg_fail(2)) SWIG_fail;
19646 }
19647 }
19648 if (obj2) {
19649 {
19650 arg3 = (int)(SWIG_As_int(obj2));
19651 if (SWIG_arg_fail(3)) SWIG_fail;
19652 }
19653 }
19654 if (obj3) {
19655 {
19656 arg4 = (int)(SWIG_As_int(obj3));
19657 if (SWIG_arg_fail(4)) SWIG_fail;
19658 }
19659 }
19660 {
19661 PyThreadState* __tstate = wxPyBeginAllowThreads();
19662 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19663
19664 wxPyEndAllowThreads(__tstate);
19665 if (PyErr_Occurred()) SWIG_fail;
19666 }
19667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19668 return resultobj;
19669 fail:
19670 return NULL;
19671 }
19672
19673
19674 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj;
19676 int arg1 ;
19677 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19678 int arg3 = (int) wxDateTime::Inv_Year ;
19679 int arg4 = (int) 0 ;
19680 int arg5 = (int) 0 ;
19681 int arg6 = (int) 0 ;
19682 int arg7 = (int) 0 ;
19683 wxDateTime *result;
19684 PyObject * obj0 = 0 ;
19685 PyObject * obj1 = 0 ;
19686 PyObject * obj2 = 0 ;
19687 PyObject * obj3 = 0 ;
19688 PyObject * obj4 = 0 ;
19689 PyObject * obj5 = 0 ;
19690 PyObject * obj6 = 0 ;
19691 char *kwnames[] = {
19692 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19693 };
19694
19695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19696 {
19697 arg1 = (int)(SWIG_As_int(obj0));
19698 if (SWIG_arg_fail(1)) SWIG_fail;
19699 }
19700 if (obj1) {
19701 {
19702 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19703 if (SWIG_arg_fail(2)) SWIG_fail;
19704 }
19705 }
19706 if (obj2) {
19707 {
19708 arg3 = (int)(SWIG_As_int(obj2));
19709 if (SWIG_arg_fail(3)) SWIG_fail;
19710 }
19711 }
19712 if (obj3) {
19713 {
19714 arg4 = (int)(SWIG_As_int(obj3));
19715 if (SWIG_arg_fail(4)) SWIG_fail;
19716 }
19717 }
19718 if (obj4) {
19719 {
19720 arg5 = (int)(SWIG_As_int(obj4));
19721 if (SWIG_arg_fail(5)) SWIG_fail;
19722 }
19723 }
19724 if (obj5) {
19725 {
19726 arg6 = (int)(SWIG_As_int(obj5));
19727 if (SWIG_arg_fail(6)) SWIG_fail;
19728 }
19729 }
19730 if (obj6) {
19731 {
19732 arg7 = (int)(SWIG_As_int(obj6));
19733 if (SWIG_arg_fail(7)) SWIG_fail;
19734 }
19735 }
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19739
19740 wxPyEndAllowThreads(__tstate);
19741 if (PyErr_Occurred()) SWIG_fail;
19742 }
19743 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19744 return resultobj;
19745 fail:
19746 return NULL;
19747 }
19748
19749
19750 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19751 PyObject *resultobj;
19752 wxDateTime *arg1 = (wxDateTime *) 0 ;
19753 PyObject * obj0 = 0 ;
19754 char *kwnames[] = {
19755 (char *) "self", NULL
19756 };
19757
19758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19760 if (SWIG_arg_fail(1)) SWIG_fail;
19761 {
19762 PyThreadState* __tstate = wxPyBeginAllowThreads();
19763 delete arg1;
19764
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 Py_INCREF(Py_None); resultobj = Py_None;
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj;
19777 wxDateTime *arg1 = (wxDateTime *) 0 ;
19778 wxDateTime *result;
19779 PyObject * obj0 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 {
19790 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19791 result = (wxDateTime *) &_result_ref;
19792 }
19793
19794 wxPyEndAllowThreads(__tstate);
19795 if (PyErr_Occurred()) SWIG_fail;
19796 }
19797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19798 return resultobj;
19799 fail:
19800 return NULL;
19801 }
19802
19803
19804 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19805 PyObject *resultobj;
19806 wxDateTime *arg1 = (wxDateTime *) 0 ;
19807 time_t arg2 ;
19808 wxDateTime *result;
19809 PyObject * obj0 = 0 ;
19810 PyObject * obj1 = 0 ;
19811 char *kwnames[] = {
19812 (char *) "self",(char *) "timet", NULL
19813 };
19814
19815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19817 if (SWIG_arg_fail(1)) SWIG_fail;
19818 {
19819 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19820 if (SWIG_arg_fail(2)) SWIG_fail;
19821 }
19822 {
19823 PyThreadState* __tstate = wxPyBeginAllowThreads();
19824 {
19825 wxDateTime &_result_ref = (arg1)->Set(arg2);
19826 result = (wxDateTime *) &_result_ref;
19827 }
19828
19829 wxPyEndAllowThreads(__tstate);
19830 if (PyErr_Occurred()) SWIG_fail;
19831 }
19832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19833 return resultobj;
19834 fail:
19835 return NULL;
19836 }
19837
19838
19839 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19840 PyObject *resultobj;
19841 wxDateTime *arg1 = (wxDateTime *) 0 ;
19842 double arg2 ;
19843 wxDateTime *result;
19844 PyObject * obj0 = 0 ;
19845 PyObject * obj1 = 0 ;
19846 char *kwnames[] = {
19847 (char *) "self",(char *) "jdn", NULL
19848 };
19849
19850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19852 if (SWIG_arg_fail(1)) SWIG_fail;
19853 {
19854 arg2 = (double)(SWIG_As_double(obj1));
19855 if (SWIG_arg_fail(2)) SWIG_fail;
19856 }
19857 {
19858 PyThreadState* __tstate = wxPyBeginAllowThreads();
19859 {
19860 wxDateTime &_result_ref = (arg1)->Set(arg2);
19861 result = (wxDateTime *) &_result_ref;
19862 }
19863
19864 wxPyEndAllowThreads(__tstate);
19865 if (PyErr_Occurred()) SWIG_fail;
19866 }
19867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19868 return resultobj;
19869 fail:
19870 return NULL;
19871 }
19872
19873
19874 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19875 PyObject *resultobj;
19876 wxDateTime *arg1 = (wxDateTime *) 0 ;
19877 int arg2 ;
19878 int arg3 = (int) 0 ;
19879 int arg4 = (int) 0 ;
19880 int arg5 = (int) 0 ;
19881 wxDateTime *result;
19882 PyObject * obj0 = 0 ;
19883 PyObject * obj1 = 0 ;
19884 PyObject * obj2 = 0 ;
19885 PyObject * obj3 = 0 ;
19886 PyObject * obj4 = 0 ;
19887 char *kwnames[] = {
19888 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19889 };
19890
19891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 {
19895 arg2 = (int)(SWIG_As_int(obj1));
19896 if (SWIG_arg_fail(2)) SWIG_fail;
19897 }
19898 if (obj2) {
19899 {
19900 arg3 = (int)(SWIG_As_int(obj2));
19901 if (SWIG_arg_fail(3)) SWIG_fail;
19902 }
19903 }
19904 if (obj3) {
19905 {
19906 arg4 = (int)(SWIG_As_int(obj3));
19907 if (SWIG_arg_fail(4)) SWIG_fail;
19908 }
19909 }
19910 if (obj4) {
19911 {
19912 arg5 = (int)(SWIG_As_int(obj4));
19913 if (SWIG_arg_fail(5)) SWIG_fail;
19914 }
19915 }
19916 {
19917 PyThreadState* __tstate = wxPyBeginAllowThreads();
19918 {
19919 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19920 result = (wxDateTime *) &_result_ref;
19921 }
19922
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19927 return resultobj;
19928 fail:
19929 return NULL;
19930 }
19931
19932
19933 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxDateTime *arg1 = (wxDateTime *) 0 ;
19936 int arg2 ;
19937 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19938 int arg4 = (int) wxDateTime::Inv_Year ;
19939 int arg5 = (int) 0 ;
19940 int arg6 = (int) 0 ;
19941 int arg7 = (int) 0 ;
19942 int arg8 = (int) 0 ;
19943 wxDateTime *result;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 PyObject * obj2 = 0 ;
19947 PyObject * obj3 = 0 ;
19948 PyObject * obj4 = 0 ;
19949 PyObject * obj5 = 0 ;
19950 PyObject * obj6 = 0 ;
19951 PyObject * obj7 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 {
19960 arg2 = (int)(SWIG_As_int(obj1));
19961 if (SWIG_arg_fail(2)) SWIG_fail;
19962 }
19963 if (obj2) {
19964 {
19965 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19966 if (SWIG_arg_fail(3)) SWIG_fail;
19967 }
19968 }
19969 if (obj3) {
19970 {
19971 arg4 = (int)(SWIG_As_int(obj3));
19972 if (SWIG_arg_fail(4)) SWIG_fail;
19973 }
19974 }
19975 if (obj4) {
19976 {
19977 arg5 = (int)(SWIG_As_int(obj4));
19978 if (SWIG_arg_fail(5)) SWIG_fail;
19979 }
19980 }
19981 if (obj5) {
19982 {
19983 arg6 = (int)(SWIG_As_int(obj5));
19984 if (SWIG_arg_fail(6)) SWIG_fail;
19985 }
19986 }
19987 if (obj6) {
19988 {
19989 arg7 = (int)(SWIG_As_int(obj6));
19990 if (SWIG_arg_fail(7)) SWIG_fail;
19991 }
19992 }
19993 if (obj7) {
19994 {
19995 arg8 = (int)(SWIG_As_int(obj7));
19996 if (SWIG_arg_fail(8)) SWIG_fail;
19997 }
19998 }
19999 {
20000 PyThreadState* __tstate = wxPyBeginAllowThreads();
20001 {
20002 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20003 result = (wxDateTime *) &_result_ref;
20004 }
20005
20006 wxPyEndAllowThreads(__tstate);
20007 if (PyErr_Occurred()) SWIG_fail;
20008 }
20009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20010 return resultobj;
20011 fail:
20012 return NULL;
20013 }
20014
20015
20016 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20017 PyObject *resultobj;
20018 wxDateTime *arg1 = (wxDateTime *) 0 ;
20019 wxDateTime *result;
20020 PyObject * obj0 = 0 ;
20021 char *kwnames[] = {
20022 (char *) "self", NULL
20023 };
20024
20025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20027 if (SWIG_arg_fail(1)) SWIG_fail;
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 {
20031 wxDateTime &_result_ref = (arg1)->ResetTime();
20032 result = (wxDateTime *) &_result_ref;
20033 }
20034
20035 wxPyEndAllowThreads(__tstate);
20036 if (PyErr_Occurred()) SWIG_fail;
20037 }
20038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20039 return resultobj;
20040 fail:
20041 return NULL;
20042 }
20043
20044
20045 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20046 PyObject *resultobj;
20047 wxDateTime *arg1 = (wxDateTime *) 0 ;
20048 int arg2 ;
20049 wxDateTime *result;
20050 PyObject * obj0 = 0 ;
20051 PyObject * obj1 = 0 ;
20052 char *kwnames[] = {
20053 (char *) "self",(char *) "year", NULL
20054 };
20055
20056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20058 if (SWIG_arg_fail(1)) SWIG_fail;
20059 {
20060 arg2 = (int)(SWIG_As_int(obj1));
20061 if (SWIG_arg_fail(2)) SWIG_fail;
20062 }
20063 {
20064 PyThreadState* __tstate = wxPyBeginAllowThreads();
20065 {
20066 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20067 result = (wxDateTime *) &_result_ref;
20068 }
20069
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20074 return resultobj;
20075 fail:
20076 return NULL;
20077 }
20078
20079
20080 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20081 PyObject *resultobj;
20082 wxDateTime *arg1 = (wxDateTime *) 0 ;
20083 wxDateTime::Month arg2 ;
20084 wxDateTime *result;
20085 PyObject * obj0 = 0 ;
20086 PyObject * obj1 = 0 ;
20087 char *kwnames[] = {
20088 (char *) "self",(char *) "month", NULL
20089 };
20090
20091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20093 if (SWIG_arg_fail(1)) SWIG_fail;
20094 {
20095 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20096 if (SWIG_arg_fail(2)) SWIG_fail;
20097 }
20098 {
20099 PyThreadState* __tstate = wxPyBeginAllowThreads();
20100 {
20101 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20102 result = (wxDateTime *) &_result_ref;
20103 }
20104
20105 wxPyEndAllowThreads(__tstate);
20106 if (PyErr_Occurred()) SWIG_fail;
20107 }
20108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20109 return resultobj;
20110 fail:
20111 return NULL;
20112 }
20113
20114
20115 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj;
20117 wxDateTime *arg1 = (wxDateTime *) 0 ;
20118 int arg2 ;
20119 wxDateTime *result;
20120 PyObject * obj0 = 0 ;
20121 PyObject * obj1 = 0 ;
20122 char *kwnames[] = {
20123 (char *) "self",(char *) "day", NULL
20124 };
20125
20126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20128 if (SWIG_arg_fail(1)) SWIG_fail;
20129 {
20130 arg2 = (int)(SWIG_As_int(obj1));
20131 if (SWIG_arg_fail(2)) SWIG_fail;
20132 }
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 {
20136 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20137 result = (wxDateTime *) &_result_ref;
20138 }
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20144 return resultobj;
20145 fail:
20146 return NULL;
20147 }
20148
20149
20150 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20151 PyObject *resultobj;
20152 wxDateTime *arg1 = (wxDateTime *) 0 ;
20153 int arg2 ;
20154 wxDateTime *result;
20155 PyObject * obj0 = 0 ;
20156 PyObject * obj1 = 0 ;
20157 char *kwnames[] = {
20158 (char *) "self",(char *) "hour", NULL
20159 };
20160
20161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20163 if (SWIG_arg_fail(1)) SWIG_fail;
20164 {
20165 arg2 = (int)(SWIG_As_int(obj1));
20166 if (SWIG_arg_fail(2)) SWIG_fail;
20167 }
20168 {
20169 PyThreadState* __tstate = wxPyBeginAllowThreads();
20170 {
20171 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20172 result = (wxDateTime *) &_result_ref;
20173 }
20174
20175 wxPyEndAllowThreads(__tstate);
20176 if (PyErr_Occurred()) SWIG_fail;
20177 }
20178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20186 PyObject *resultobj;
20187 wxDateTime *arg1 = (wxDateTime *) 0 ;
20188 int arg2 ;
20189 wxDateTime *result;
20190 PyObject * obj0 = 0 ;
20191 PyObject * obj1 = 0 ;
20192 char *kwnames[] = {
20193 (char *) "self",(char *) "minute", NULL
20194 };
20195
20196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20198 if (SWIG_arg_fail(1)) SWIG_fail;
20199 {
20200 arg2 = (int)(SWIG_As_int(obj1));
20201 if (SWIG_arg_fail(2)) SWIG_fail;
20202 }
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 {
20206 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20207 result = (wxDateTime *) &_result_ref;
20208 }
20209
20210 wxPyEndAllowThreads(__tstate);
20211 if (PyErr_Occurred()) SWIG_fail;
20212 }
20213 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20214 return resultobj;
20215 fail:
20216 return NULL;
20217 }
20218
20219
20220 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20221 PyObject *resultobj;
20222 wxDateTime *arg1 = (wxDateTime *) 0 ;
20223 int arg2 ;
20224 wxDateTime *result;
20225 PyObject * obj0 = 0 ;
20226 PyObject * obj1 = 0 ;
20227 char *kwnames[] = {
20228 (char *) "self",(char *) "second", NULL
20229 };
20230
20231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20233 if (SWIG_arg_fail(1)) SWIG_fail;
20234 {
20235 arg2 = (int)(SWIG_As_int(obj1));
20236 if (SWIG_arg_fail(2)) SWIG_fail;
20237 }
20238 {
20239 PyThreadState* __tstate = wxPyBeginAllowThreads();
20240 {
20241 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20242 result = (wxDateTime *) &_result_ref;
20243 }
20244
20245 wxPyEndAllowThreads(__tstate);
20246 if (PyErr_Occurred()) SWIG_fail;
20247 }
20248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20249 return resultobj;
20250 fail:
20251 return NULL;
20252 }
20253
20254
20255 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20256 PyObject *resultobj;
20257 wxDateTime *arg1 = (wxDateTime *) 0 ;
20258 int arg2 ;
20259 wxDateTime *result;
20260 PyObject * obj0 = 0 ;
20261 PyObject * obj1 = 0 ;
20262 char *kwnames[] = {
20263 (char *) "self",(char *) "millisecond", NULL
20264 };
20265
20266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20268 if (SWIG_arg_fail(1)) SWIG_fail;
20269 {
20270 arg2 = (int)(SWIG_As_int(obj1));
20271 if (SWIG_arg_fail(2)) SWIG_fail;
20272 }
20273 {
20274 PyThreadState* __tstate = wxPyBeginAllowThreads();
20275 {
20276 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20277 result = (wxDateTime *) &_result_ref;
20278 }
20279
20280 wxPyEndAllowThreads(__tstate);
20281 if (PyErr_Occurred()) SWIG_fail;
20282 }
20283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20291 PyObject *resultobj;
20292 wxDateTime *arg1 = (wxDateTime *) 0 ;
20293 wxDateTime::WeekDay arg2 ;
20294 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20295 wxDateTime *result;
20296 PyObject * obj0 = 0 ;
20297 PyObject * obj1 = 0 ;
20298 PyObject * obj2 = 0 ;
20299 char *kwnames[] = {
20300 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20301 };
20302
20303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20305 if (SWIG_arg_fail(1)) SWIG_fail;
20306 {
20307 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20308 if (SWIG_arg_fail(2)) SWIG_fail;
20309 }
20310 if (obj2) {
20311 {
20312 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20313 if (SWIG_arg_fail(3)) SWIG_fail;
20314 }
20315 }
20316 {
20317 PyThreadState* __tstate = wxPyBeginAllowThreads();
20318 {
20319 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20320 result = (wxDateTime *) &_result_ref;
20321 }
20322
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20334 PyObject *resultobj;
20335 wxDateTime *arg1 = (wxDateTime *) 0 ;
20336 wxDateTime::WeekDay arg2 ;
20337 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20338 wxDateTime result;
20339 PyObject * obj0 = 0 ;
20340 PyObject * obj1 = 0 ;
20341 PyObject * obj2 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20351 if (SWIG_arg_fail(2)) SWIG_fail;
20352 }
20353 if (obj2) {
20354 {
20355 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20356 if (SWIG_arg_fail(3)) SWIG_fail;
20357 }
20358 }
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20362
20363 wxPyEndAllowThreads(__tstate);
20364 if (PyErr_Occurred()) SWIG_fail;
20365 }
20366 {
20367 wxDateTime * resultptr;
20368 resultptr = new wxDateTime((wxDateTime &)(result));
20369 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20370 }
20371 return resultobj;
20372 fail:
20373 return NULL;
20374 }
20375
20376
20377 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20378 PyObject *resultobj;
20379 wxDateTime *arg1 = (wxDateTime *) 0 ;
20380 wxDateTime::WeekDay arg2 ;
20381 wxDateTime *result;
20382 PyObject * obj0 = 0 ;
20383 PyObject * obj1 = 0 ;
20384 char *kwnames[] = {
20385 (char *) "self",(char *) "weekday", NULL
20386 };
20387
20388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20390 if (SWIG_arg_fail(1)) SWIG_fail;
20391 {
20392 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20393 if (SWIG_arg_fail(2)) SWIG_fail;
20394 }
20395 {
20396 PyThreadState* __tstate = wxPyBeginAllowThreads();
20397 {
20398 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20399 result = (wxDateTime *) &_result_ref;
20400 }
20401
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20406 return resultobj;
20407 fail:
20408 return NULL;
20409 }
20410
20411
20412 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20413 PyObject *resultobj;
20414 wxDateTime *arg1 = (wxDateTime *) 0 ;
20415 wxDateTime::WeekDay arg2 ;
20416 wxDateTime result;
20417 PyObject * obj0 = 0 ;
20418 PyObject * obj1 = 0 ;
20419 char *kwnames[] = {
20420 (char *) "self",(char *) "weekday", NULL
20421 };
20422
20423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20425 if (SWIG_arg_fail(1)) SWIG_fail;
20426 {
20427 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20428 if (SWIG_arg_fail(2)) SWIG_fail;
20429 }
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20433
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 {
20438 wxDateTime * resultptr;
20439 resultptr = new wxDateTime((wxDateTime &)(result));
20440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20441 }
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20449 PyObject *resultobj;
20450 wxDateTime *arg1 = (wxDateTime *) 0 ;
20451 wxDateTime::WeekDay arg2 ;
20452 wxDateTime *result;
20453 PyObject * obj0 = 0 ;
20454 PyObject * obj1 = 0 ;
20455 char *kwnames[] = {
20456 (char *) "self",(char *) "weekday", NULL
20457 };
20458
20459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20461 if (SWIG_arg_fail(1)) SWIG_fail;
20462 {
20463 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20464 if (SWIG_arg_fail(2)) SWIG_fail;
20465 }
20466 {
20467 PyThreadState* __tstate = wxPyBeginAllowThreads();
20468 {
20469 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20470 result = (wxDateTime *) &_result_ref;
20471 }
20472
20473 wxPyEndAllowThreads(__tstate);
20474 if (PyErr_Occurred()) SWIG_fail;
20475 }
20476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20477 return resultobj;
20478 fail:
20479 return NULL;
20480 }
20481
20482
20483 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20484 PyObject *resultobj;
20485 wxDateTime *arg1 = (wxDateTime *) 0 ;
20486 wxDateTime::WeekDay arg2 ;
20487 wxDateTime result;
20488 PyObject * obj0 = 0 ;
20489 PyObject * obj1 = 0 ;
20490 char *kwnames[] = {
20491 (char *) "self",(char *) "weekday", NULL
20492 };
20493
20494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20496 if (SWIG_arg_fail(1)) SWIG_fail;
20497 {
20498 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20499 if (SWIG_arg_fail(2)) SWIG_fail;
20500 }
20501 {
20502 PyThreadState* __tstate = wxPyBeginAllowThreads();
20503 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20504
20505 wxPyEndAllowThreads(__tstate);
20506 if (PyErr_Occurred()) SWIG_fail;
20507 }
20508 {
20509 wxDateTime * resultptr;
20510 resultptr = new wxDateTime((wxDateTime &)(result));
20511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20512 }
20513 return resultobj;
20514 fail:
20515 return NULL;
20516 }
20517
20518
20519 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20520 PyObject *resultobj;
20521 wxDateTime *arg1 = (wxDateTime *) 0 ;
20522 wxDateTime::WeekDay arg2 ;
20523 int arg3 = (int) 1 ;
20524 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20525 int arg5 = (int) wxDateTime::Inv_Year ;
20526 bool result;
20527 PyObject * obj0 = 0 ;
20528 PyObject * obj1 = 0 ;
20529 PyObject * obj2 = 0 ;
20530 PyObject * obj3 = 0 ;
20531 PyObject * obj4 = 0 ;
20532 char *kwnames[] = {
20533 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20534 };
20535
20536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20538 if (SWIG_arg_fail(1)) SWIG_fail;
20539 {
20540 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20541 if (SWIG_arg_fail(2)) SWIG_fail;
20542 }
20543 if (obj2) {
20544 {
20545 arg3 = (int)(SWIG_As_int(obj2));
20546 if (SWIG_arg_fail(3)) SWIG_fail;
20547 }
20548 }
20549 if (obj3) {
20550 {
20551 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20552 if (SWIG_arg_fail(4)) SWIG_fail;
20553 }
20554 }
20555 if (obj4) {
20556 {
20557 arg5 = (int)(SWIG_As_int(obj4));
20558 if (SWIG_arg_fail(5)) SWIG_fail;
20559 }
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 {
20569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20570 }
20571 return resultobj;
20572 fail:
20573 return NULL;
20574 }
20575
20576
20577 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 wxDateTime *arg1 = (wxDateTime *) 0 ;
20580 wxDateTime::WeekDay arg2 ;
20581 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20582 int arg4 = (int) wxDateTime::Inv_Year ;
20583 bool result;
20584 PyObject * obj0 = 0 ;
20585 PyObject * obj1 = 0 ;
20586 PyObject * obj2 = 0 ;
20587 PyObject * obj3 = 0 ;
20588 char *kwnames[] = {
20589 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20590 };
20591
20592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20594 if (SWIG_arg_fail(1)) SWIG_fail;
20595 {
20596 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20597 if (SWIG_arg_fail(2)) SWIG_fail;
20598 }
20599 if (obj2) {
20600 {
20601 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20602 if (SWIG_arg_fail(3)) SWIG_fail;
20603 }
20604 }
20605 if (obj3) {
20606 {
20607 arg4 = (int)(SWIG_As_int(obj3));
20608 if (SWIG_arg_fail(4)) SWIG_fail;
20609 }
20610 }
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20614
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 {
20619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20620 }
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj;
20629 wxDateTime *arg1 = (wxDateTime *) 0 ;
20630 wxDateTime::WeekDay arg2 ;
20631 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20632 int arg4 = (int) wxDateTime::Inv_Year ;
20633 wxDateTime result;
20634 PyObject * obj0 = 0 ;
20635 PyObject * obj1 = 0 ;
20636 PyObject * obj2 = 0 ;
20637 PyObject * obj3 = 0 ;
20638 char *kwnames[] = {
20639 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20640 };
20641
20642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20644 if (SWIG_arg_fail(1)) SWIG_fail;
20645 {
20646 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20647 if (SWIG_arg_fail(2)) SWIG_fail;
20648 }
20649 if (obj2) {
20650 {
20651 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20652 if (SWIG_arg_fail(3)) SWIG_fail;
20653 }
20654 }
20655 if (obj3) {
20656 {
20657 arg4 = (int)(SWIG_As_int(obj3));
20658 if (SWIG_arg_fail(4)) SWIG_fail;
20659 }
20660 }
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20664
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 {
20669 wxDateTime * resultptr;
20670 resultptr = new wxDateTime((wxDateTime &)(result));
20671 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20672 }
20673 return resultobj;
20674 fail:
20675 return NULL;
20676 }
20677
20678
20679 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20680 PyObject *resultobj;
20681 wxDateTime *arg1 = (wxDateTime *) 0 ;
20682 int arg2 ;
20683 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20684 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20685 bool result;
20686 PyObject * obj0 = 0 ;
20687 PyObject * obj1 = 0 ;
20688 PyObject * obj2 = 0 ;
20689 PyObject * obj3 = 0 ;
20690 char *kwnames[] = {
20691 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20692 };
20693
20694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20696 if (SWIG_arg_fail(1)) SWIG_fail;
20697 {
20698 arg2 = (int)(SWIG_As_int(obj1));
20699 if (SWIG_arg_fail(2)) SWIG_fail;
20700 }
20701 if (obj2) {
20702 {
20703 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20704 if (SWIG_arg_fail(3)) SWIG_fail;
20705 }
20706 }
20707 if (obj3) {
20708 {
20709 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20710 if (SWIG_arg_fail(4)) SWIG_fail;
20711 }
20712 }
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20716
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 wxDateTime *arg1 = (wxDateTime *) 0 ;
20732 int arg2 ;
20733 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20734 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20735 wxDateTime result;
20736 PyObject * obj0 = 0 ;
20737 PyObject * obj1 = 0 ;
20738 PyObject * obj2 = 0 ;
20739 PyObject * obj3 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20746 if (SWIG_arg_fail(1)) SWIG_fail;
20747 {
20748 arg2 = (int)(SWIG_As_int(obj1));
20749 if (SWIG_arg_fail(2)) SWIG_fail;
20750 }
20751 if (obj2) {
20752 {
20753 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20754 if (SWIG_arg_fail(3)) SWIG_fail;
20755 }
20756 }
20757 if (obj3) {
20758 {
20759 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20760 if (SWIG_arg_fail(4)) SWIG_fail;
20761 }
20762 }
20763 {
20764 PyThreadState* __tstate = wxPyBeginAllowThreads();
20765 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20766
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 {
20771 wxDateTime * resultptr;
20772 resultptr = new wxDateTime((wxDateTime &)(result));
20773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20774 }
20775 return resultobj;
20776 fail:
20777 return NULL;
20778 }
20779
20780
20781 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20782 PyObject *resultobj;
20783 int arg1 ;
20784 int arg2 ;
20785 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20786 wxDateTime result;
20787 PyObject * obj0 = 0 ;
20788 PyObject * obj1 = 0 ;
20789 PyObject * obj2 = 0 ;
20790 char *kwnames[] = {
20791 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20792 };
20793
20794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20795 {
20796 arg1 = (int)(SWIG_As_int(obj0));
20797 if (SWIG_arg_fail(1)) SWIG_fail;
20798 }
20799 {
20800 arg2 = (int)(SWIG_As_int(obj1));
20801 if (SWIG_arg_fail(2)) SWIG_fail;
20802 }
20803 if (obj2) {
20804 {
20805 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20806 if (SWIG_arg_fail(3)) SWIG_fail;
20807 }
20808 }
20809 {
20810 PyThreadState* __tstate = wxPyBeginAllowThreads();
20811 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20812
20813 wxPyEndAllowThreads(__tstate);
20814 if (PyErr_Occurred()) SWIG_fail;
20815 }
20816 {
20817 wxDateTime * resultptr;
20818 resultptr = new wxDateTime((wxDateTime &)(result));
20819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20820 }
20821 return resultobj;
20822 fail:
20823 return NULL;
20824 }
20825
20826
20827 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20828 PyObject *resultobj;
20829 wxDateTime *arg1 = (wxDateTime *) 0 ;
20830 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20831 int arg3 = (int) wxDateTime::Inv_Year ;
20832 wxDateTime *result;
20833 PyObject * obj0 = 0 ;
20834 PyObject * obj1 = 0 ;
20835 PyObject * obj2 = 0 ;
20836 char *kwnames[] = {
20837 (char *) "self",(char *) "month",(char *) "year", NULL
20838 };
20839
20840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20842 if (SWIG_arg_fail(1)) SWIG_fail;
20843 if (obj1) {
20844 {
20845 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20846 if (SWIG_arg_fail(2)) SWIG_fail;
20847 }
20848 }
20849 if (obj2) {
20850 {
20851 arg3 = (int)(SWIG_As_int(obj2));
20852 if (SWIG_arg_fail(3)) SWIG_fail;
20853 }
20854 }
20855 {
20856 PyThreadState* __tstate = wxPyBeginAllowThreads();
20857 {
20858 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20859 result = (wxDateTime *) &_result_ref;
20860 }
20861
20862 wxPyEndAllowThreads(__tstate);
20863 if (PyErr_Occurred()) SWIG_fail;
20864 }
20865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20866 return resultobj;
20867 fail:
20868 return NULL;
20869 }
20870
20871
20872 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20873 PyObject *resultobj;
20874 wxDateTime *arg1 = (wxDateTime *) 0 ;
20875 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20876 int arg3 = (int) wxDateTime::Inv_Year ;
20877 wxDateTime result;
20878 PyObject * obj0 = 0 ;
20879 PyObject * obj1 = 0 ;
20880 PyObject * obj2 = 0 ;
20881 char *kwnames[] = {
20882 (char *) "self",(char *) "month",(char *) "year", NULL
20883 };
20884
20885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20887 if (SWIG_arg_fail(1)) SWIG_fail;
20888 if (obj1) {
20889 {
20890 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20891 if (SWIG_arg_fail(2)) SWIG_fail;
20892 }
20893 }
20894 if (obj2) {
20895 {
20896 arg3 = (int)(SWIG_As_int(obj2));
20897 if (SWIG_arg_fail(3)) SWIG_fail;
20898 }
20899 }
20900 {
20901 PyThreadState* __tstate = wxPyBeginAllowThreads();
20902 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20903
20904 wxPyEndAllowThreads(__tstate);
20905 if (PyErr_Occurred()) SWIG_fail;
20906 }
20907 {
20908 wxDateTime * resultptr;
20909 resultptr = new wxDateTime((wxDateTime &)(result));
20910 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20911 }
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20919 PyObject *resultobj;
20920 wxDateTime *arg1 = (wxDateTime *) 0 ;
20921 int arg2 ;
20922 wxDateTime *result;
20923 PyObject * obj0 = 0 ;
20924 PyObject * obj1 = 0 ;
20925 char *kwnames[] = {
20926 (char *) "self",(char *) "yday", NULL
20927 };
20928
20929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20931 if (SWIG_arg_fail(1)) SWIG_fail;
20932 {
20933 arg2 = (int)(SWIG_As_int(obj1));
20934 if (SWIG_arg_fail(2)) SWIG_fail;
20935 }
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 {
20939 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20940 result = (wxDateTime *) &_result_ref;
20941 }
20942
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20954 PyObject *resultobj;
20955 wxDateTime *arg1 = (wxDateTime *) 0 ;
20956 int arg2 ;
20957 wxDateTime result;
20958 PyObject * obj0 = 0 ;
20959 PyObject * obj1 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self",(char *) "yday", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 {
20968 arg2 = (int)(SWIG_As_int(obj1));
20969 if (SWIG_arg_fail(2)) SWIG_fail;
20970 }
20971 {
20972 PyThreadState* __tstate = wxPyBeginAllowThreads();
20973 result = (arg1)->GetYearDay(arg2);
20974
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 {
20979 wxDateTime * resultptr;
20980 resultptr = new wxDateTime((wxDateTime &)(result));
20981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20982 }
20983 return resultobj;
20984 fail:
20985 return NULL;
20986 }
20987
20988
20989 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
20990 PyObject *resultobj;
20991 wxDateTime *arg1 = (wxDateTime *) 0 ;
20992 double result;
20993 PyObject * obj0 = 0 ;
20994 char *kwnames[] = {
20995 (char *) "self", NULL
20996 };
20997
20998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
20999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21000 if (SWIG_arg_fail(1)) SWIG_fail;
21001 {
21002 PyThreadState* __tstate = wxPyBeginAllowThreads();
21003 result = (double)(arg1)->GetJulianDayNumber();
21004
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 {
21009 resultobj = SWIG_From_double((double)(result));
21010 }
21011 return resultobj;
21012 fail:
21013 return NULL;
21014 }
21015
21016
21017 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21018 PyObject *resultobj;
21019 wxDateTime *arg1 = (wxDateTime *) 0 ;
21020 double result;
21021 PyObject * obj0 = 0 ;
21022 char *kwnames[] = {
21023 (char *) "self", NULL
21024 };
21025
21026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21028 if (SWIG_arg_fail(1)) SWIG_fail;
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = (double)(arg1)->GetJDN();
21032
21033 wxPyEndAllowThreads(__tstate);
21034 if (PyErr_Occurred()) SWIG_fail;
21035 }
21036 {
21037 resultobj = SWIG_From_double((double)(result));
21038 }
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj;
21047 wxDateTime *arg1 = (wxDateTime *) 0 ;
21048 double result;
21049 PyObject * obj0 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 PyThreadState* __tstate = wxPyBeginAllowThreads();
21059 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21060
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 resultobj = SWIG_From_double((double)(result));
21066 }
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21074 PyObject *resultobj;
21075 wxDateTime *arg1 = (wxDateTime *) 0 ;
21076 double result;
21077 PyObject * obj0 = 0 ;
21078 char *kwnames[] = {
21079 (char *) "self", NULL
21080 };
21081
21082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21084 if (SWIG_arg_fail(1)) SWIG_fail;
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 result = (double)(arg1)->GetMJD();
21088
21089 wxPyEndAllowThreads(__tstate);
21090 if (PyErr_Occurred()) SWIG_fail;
21091 }
21092 {
21093 resultobj = SWIG_From_double((double)(result));
21094 }
21095 return resultobj;
21096 fail:
21097 return NULL;
21098 }
21099
21100
21101 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21102 PyObject *resultobj;
21103 wxDateTime *arg1 = (wxDateTime *) 0 ;
21104 double result;
21105 PyObject * obj0 = 0 ;
21106 char *kwnames[] = {
21107 (char *) "self", NULL
21108 };
21109
21110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21112 if (SWIG_arg_fail(1)) SWIG_fail;
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (double)(arg1)->GetRataDie();
21116
21117 wxPyEndAllowThreads(__tstate);
21118 if (PyErr_Occurred()) SWIG_fail;
21119 }
21120 {
21121 resultobj = SWIG_From_double((double)(result));
21122 }
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21130 PyObject *resultobj;
21131 wxDateTime *arg1 = (wxDateTime *) 0 ;
21132 wxDateTime::TimeZone *arg2 = 0 ;
21133 bool arg3 = (bool) false ;
21134 wxDateTime result;
21135 bool temp2 = false ;
21136 PyObject * obj0 = 0 ;
21137 PyObject * obj1 = 0 ;
21138 PyObject * obj2 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21148 temp2 = true;
21149 }
21150 if (obj2) {
21151 {
21152 arg3 = (bool)(SWIG_As_bool(obj2));
21153 if (SWIG_arg_fail(3)) SWIG_fail;
21154 }
21155 }
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 wxDateTime * resultptr;
21165 resultptr = new wxDateTime((wxDateTime &)(result));
21166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21167 }
21168 {
21169 if (temp2) delete arg2;
21170 }
21171 return resultobj;
21172 fail:
21173 {
21174 if (temp2) delete arg2;
21175 }
21176 return NULL;
21177 }
21178
21179
21180 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21181 PyObject *resultobj;
21182 wxDateTime *arg1 = (wxDateTime *) 0 ;
21183 wxDateTime::TimeZone *arg2 = 0 ;
21184 bool arg3 = (bool) false ;
21185 wxDateTime *result;
21186 bool temp2 = false ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 PyObject * obj2 = 0 ;
21190 char *kwnames[] = {
21191 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21192 };
21193
21194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21196 if (SWIG_arg_fail(1)) SWIG_fail;
21197 {
21198 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21199 temp2 = true;
21200 }
21201 if (obj2) {
21202 {
21203 arg3 = (bool)(SWIG_As_bool(obj2));
21204 if (SWIG_arg_fail(3)) SWIG_fail;
21205 }
21206 }
21207 {
21208 PyThreadState* __tstate = wxPyBeginAllowThreads();
21209 {
21210 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21211 result = (wxDateTime *) &_result_ref;
21212 }
21213
21214 wxPyEndAllowThreads(__tstate);
21215 if (PyErr_Occurred()) SWIG_fail;
21216 }
21217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21218 {
21219 if (temp2) delete arg2;
21220 }
21221 return resultobj;
21222 fail:
21223 {
21224 if (temp2) delete arg2;
21225 }
21226 return NULL;
21227 }
21228
21229
21230 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21231 PyObject *resultobj;
21232 wxDateTime *arg1 = (wxDateTime *) 0 ;
21233 bool arg2 = (bool) false ;
21234 wxDateTime result;
21235 PyObject * obj0 = 0 ;
21236 PyObject * obj1 = 0 ;
21237 char *kwnames[] = {
21238 (char *) "self",(char *) "noDST", NULL
21239 };
21240
21241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21243 if (SWIG_arg_fail(1)) SWIG_fail;
21244 if (obj1) {
21245 {
21246 arg2 = (bool)(SWIG_As_bool(obj1));
21247 if (SWIG_arg_fail(2)) SWIG_fail;
21248 }
21249 }
21250 {
21251 PyThreadState* __tstate = wxPyBeginAllowThreads();
21252 result = (arg1)->ToGMT(arg2);
21253
21254 wxPyEndAllowThreads(__tstate);
21255 if (PyErr_Occurred()) SWIG_fail;
21256 }
21257 {
21258 wxDateTime * resultptr;
21259 resultptr = new wxDateTime((wxDateTime &)(result));
21260 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21261 }
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj;
21270 wxDateTime *arg1 = (wxDateTime *) 0 ;
21271 bool arg2 = (bool) false ;
21272 wxDateTime *result;
21273 PyObject * obj0 = 0 ;
21274 PyObject * obj1 = 0 ;
21275 char *kwnames[] = {
21276 (char *) "self",(char *) "noDST", NULL
21277 };
21278
21279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21281 if (SWIG_arg_fail(1)) SWIG_fail;
21282 if (obj1) {
21283 {
21284 arg2 = (bool)(SWIG_As_bool(obj1));
21285 if (SWIG_arg_fail(2)) SWIG_fail;
21286 }
21287 }
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 {
21291 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21292 result = (wxDateTime *) &_result_ref;
21293 }
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj;
21307 wxDateTime *arg1 = (wxDateTime *) 0 ;
21308 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21309 int result;
21310 PyObject * obj0 = 0 ;
21311 PyObject * obj1 = 0 ;
21312 char *kwnames[] = {
21313 (char *) "self",(char *) "country", NULL
21314 };
21315
21316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(1)) SWIG_fail;
21319 if (obj1) {
21320 {
21321 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21322 if (SWIG_arg_fail(2)) SWIG_fail;
21323 }
21324 }
21325 {
21326 PyThreadState* __tstate = wxPyBeginAllowThreads();
21327 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21328
21329 wxPyEndAllowThreads(__tstate);
21330 if (PyErr_Occurred()) SWIG_fail;
21331 }
21332 {
21333 resultobj = SWIG_From_int((int)(result));
21334 }
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj;
21343 wxDateTime *arg1 = (wxDateTime *) 0 ;
21344 bool result;
21345 PyObject * obj0 = 0 ;
21346 char *kwnames[] = {
21347 (char *) "self", NULL
21348 };
21349
21350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21352 if (SWIG_arg_fail(1)) SWIG_fail;
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 result = (bool)((wxDateTime const *)arg1)->IsValid();
21356
21357 wxPyEndAllowThreads(__tstate);
21358 if (PyErr_Occurred()) SWIG_fail;
21359 }
21360 {
21361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21362 }
21363 return resultobj;
21364 fail:
21365 return NULL;
21366 }
21367
21368
21369 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21370 PyObject *resultobj;
21371 wxDateTime *arg1 = (wxDateTime *) 0 ;
21372 time_t result;
21373 PyObject * obj0 = 0 ;
21374 char *kwnames[] = {
21375 (char *) "self", NULL
21376 };
21377
21378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21380 if (SWIG_arg_fail(1)) SWIG_fail;
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21384
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 {
21389 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21390 }
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj;
21399 wxDateTime *arg1 = (wxDateTime *) 0 ;
21400 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21401 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21402 int result;
21403 bool temp2 = false ;
21404 PyObject * obj0 = 0 ;
21405 PyObject * obj1 = 0 ;
21406 char *kwnames[] = {
21407 (char *) "self",(char *) "tz", NULL
21408 };
21409
21410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21412 if (SWIG_arg_fail(1)) SWIG_fail;
21413 if (obj1) {
21414 {
21415 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21416 temp2 = true;
21417 }
21418 }
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21422
21423 wxPyEndAllowThreads(__tstate);
21424 if (PyErr_Occurred()) SWIG_fail;
21425 }
21426 {
21427 resultobj = SWIG_From_int((int)(result));
21428 }
21429 {
21430 if (temp2) delete arg2;
21431 }
21432 return resultobj;
21433 fail:
21434 {
21435 if (temp2) delete arg2;
21436 }
21437 return NULL;
21438 }
21439
21440
21441 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj;
21443 wxDateTime *arg1 = (wxDateTime *) 0 ;
21444 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21445 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21446 wxDateTime::Month result;
21447 bool temp2 = false ;
21448 PyObject * obj0 = 0 ;
21449 PyObject * obj1 = 0 ;
21450 char *kwnames[] = {
21451 (char *) "self",(char *) "tz", NULL
21452 };
21453
21454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21456 if (SWIG_arg_fail(1)) SWIG_fail;
21457 if (obj1) {
21458 {
21459 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21460 temp2 = true;
21461 }
21462 }
21463 {
21464 PyThreadState* __tstate = wxPyBeginAllowThreads();
21465 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21466
21467 wxPyEndAllowThreads(__tstate);
21468 if (PyErr_Occurred()) SWIG_fail;
21469 }
21470 resultobj = SWIG_From_int((result));
21471 {
21472 if (temp2) delete arg2;
21473 }
21474 return resultobj;
21475 fail:
21476 {
21477 if (temp2) delete arg2;
21478 }
21479 return NULL;
21480 }
21481
21482
21483 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21484 PyObject *resultobj;
21485 wxDateTime *arg1 = (wxDateTime *) 0 ;
21486 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21487 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21488 int result;
21489 bool temp2 = false ;
21490 PyObject * obj0 = 0 ;
21491 PyObject * obj1 = 0 ;
21492 char *kwnames[] = {
21493 (char *) "self",(char *) "tz", NULL
21494 };
21495
21496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21498 if (SWIG_arg_fail(1)) SWIG_fail;
21499 if (obj1) {
21500 {
21501 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21502 temp2 = true;
21503 }
21504 }
21505 {
21506 PyThreadState* __tstate = wxPyBeginAllowThreads();
21507 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21508
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 {
21513 resultobj = SWIG_From_int((int)(result));
21514 }
21515 {
21516 if (temp2) delete arg2;
21517 }
21518 return resultobj;
21519 fail:
21520 {
21521 if (temp2) delete arg2;
21522 }
21523 return NULL;
21524 }
21525
21526
21527 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj;
21529 wxDateTime *arg1 = (wxDateTime *) 0 ;
21530 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21531 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21532 wxDateTime::WeekDay result;
21533 bool temp2 = false ;
21534 PyObject * obj0 = 0 ;
21535 PyObject * obj1 = 0 ;
21536 char *kwnames[] = {
21537 (char *) "self",(char *) "tz", NULL
21538 };
21539
21540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21542 if (SWIG_arg_fail(1)) SWIG_fail;
21543 if (obj1) {
21544 {
21545 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21546 temp2 = true;
21547 }
21548 }
21549 {
21550 PyThreadState* __tstate = wxPyBeginAllowThreads();
21551 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21552
21553 wxPyEndAllowThreads(__tstate);
21554 if (PyErr_Occurred()) SWIG_fail;
21555 }
21556 resultobj = SWIG_From_int((result));
21557 {
21558 if (temp2) delete arg2;
21559 }
21560 return resultobj;
21561 fail:
21562 {
21563 if (temp2) delete arg2;
21564 }
21565 return NULL;
21566 }
21567
21568
21569 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21570 PyObject *resultobj;
21571 wxDateTime *arg1 = (wxDateTime *) 0 ;
21572 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21573 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21574 int result;
21575 bool temp2 = false ;
21576 PyObject * obj0 = 0 ;
21577 PyObject * obj1 = 0 ;
21578 char *kwnames[] = {
21579 (char *) "self",(char *) "tz", NULL
21580 };
21581
21582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21584 if (SWIG_arg_fail(1)) SWIG_fail;
21585 if (obj1) {
21586 {
21587 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21588 temp2 = true;
21589 }
21590 }
21591 {
21592 PyThreadState* __tstate = wxPyBeginAllowThreads();
21593 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21594
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 {
21599 resultobj = SWIG_From_int((int)(result));
21600 }
21601 {
21602 if (temp2) delete arg2;
21603 }
21604 return resultobj;
21605 fail:
21606 {
21607 if (temp2) delete arg2;
21608 }
21609 return NULL;
21610 }
21611
21612
21613 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21614 PyObject *resultobj;
21615 wxDateTime *arg1 = (wxDateTime *) 0 ;
21616 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21617 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21618 int result;
21619 bool temp2 = false ;
21620 PyObject * obj0 = 0 ;
21621 PyObject * obj1 = 0 ;
21622 char *kwnames[] = {
21623 (char *) "self",(char *) "tz", NULL
21624 };
21625
21626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21628 if (SWIG_arg_fail(1)) SWIG_fail;
21629 if (obj1) {
21630 {
21631 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21632 temp2 = true;
21633 }
21634 }
21635 {
21636 PyThreadState* __tstate = wxPyBeginAllowThreads();
21637 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21638
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 {
21643 resultobj = SWIG_From_int((int)(result));
21644 }
21645 {
21646 if (temp2) delete arg2;
21647 }
21648 return resultobj;
21649 fail:
21650 {
21651 if (temp2) delete arg2;
21652 }
21653 return NULL;
21654 }
21655
21656
21657 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21658 PyObject *resultobj;
21659 wxDateTime *arg1 = (wxDateTime *) 0 ;
21660 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21661 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21662 int result;
21663 bool temp2 = false ;
21664 PyObject * obj0 = 0 ;
21665 PyObject * obj1 = 0 ;
21666 char *kwnames[] = {
21667 (char *) "self",(char *) "tz", NULL
21668 };
21669
21670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21672 if (SWIG_arg_fail(1)) SWIG_fail;
21673 if (obj1) {
21674 {
21675 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21676 temp2 = true;
21677 }
21678 }
21679 {
21680 PyThreadState* __tstate = wxPyBeginAllowThreads();
21681 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21682
21683 wxPyEndAllowThreads(__tstate);
21684 if (PyErr_Occurred()) SWIG_fail;
21685 }
21686 {
21687 resultobj = SWIG_From_int((int)(result));
21688 }
21689 {
21690 if (temp2) delete arg2;
21691 }
21692 return resultobj;
21693 fail:
21694 {
21695 if (temp2) delete arg2;
21696 }
21697 return NULL;
21698 }
21699
21700
21701 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21702 PyObject *resultobj;
21703 wxDateTime *arg1 = (wxDateTime *) 0 ;
21704 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21705 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21706 int result;
21707 bool temp2 = false ;
21708 PyObject * obj0 = 0 ;
21709 PyObject * obj1 = 0 ;
21710 char *kwnames[] = {
21711 (char *) "self",(char *) "tz", NULL
21712 };
21713
21714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21716 if (SWIG_arg_fail(1)) SWIG_fail;
21717 if (obj1) {
21718 {
21719 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21720 temp2 = true;
21721 }
21722 }
21723 {
21724 PyThreadState* __tstate = wxPyBeginAllowThreads();
21725 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21726
21727 wxPyEndAllowThreads(__tstate);
21728 if (PyErr_Occurred()) SWIG_fail;
21729 }
21730 {
21731 resultobj = SWIG_From_int((int)(result));
21732 }
21733 {
21734 if (temp2) delete arg2;
21735 }
21736 return resultobj;
21737 fail:
21738 {
21739 if (temp2) delete arg2;
21740 }
21741 return NULL;
21742 }
21743
21744
21745 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj;
21747 wxDateTime *arg1 = (wxDateTime *) 0 ;
21748 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21749 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21750 int result;
21751 bool temp2 = false ;
21752 PyObject * obj0 = 0 ;
21753 PyObject * obj1 = 0 ;
21754 char *kwnames[] = {
21755 (char *) "self",(char *) "tz", NULL
21756 };
21757
21758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21760 if (SWIG_arg_fail(1)) SWIG_fail;
21761 if (obj1) {
21762 {
21763 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21764 temp2 = true;
21765 }
21766 }
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21770
21771 wxPyEndAllowThreads(__tstate);
21772 if (PyErr_Occurred()) SWIG_fail;
21773 }
21774 {
21775 resultobj = SWIG_From_int((int)(result));
21776 }
21777 {
21778 if (temp2) delete arg2;
21779 }
21780 return resultobj;
21781 fail:
21782 {
21783 if (temp2) delete arg2;
21784 }
21785 return NULL;
21786 }
21787
21788
21789 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21790 PyObject *resultobj;
21791 wxDateTime *arg1 = (wxDateTime *) 0 ;
21792 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21793 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21794 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21795 int result;
21796 bool temp3 = false ;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 PyObject * obj2 = 0 ;
21800 char *kwnames[] = {
21801 (char *) "self",(char *) "flags",(char *) "tz", NULL
21802 };
21803
21804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21806 if (SWIG_arg_fail(1)) SWIG_fail;
21807 if (obj1) {
21808 {
21809 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21810 if (SWIG_arg_fail(2)) SWIG_fail;
21811 }
21812 }
21813 if (obj2) {
21814 {
21815 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21816 temp3 = true;
21817 }
21818 }
21819 {
21820 PyThreadState* __tstate = wxPyBeginAllowThreads();
21821 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21822
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 {
21827 resultobj = SWIG_From_int((int)(result));
21828 }
21829 {
21830 if (temp3) delete arg3;
21831 }
21832 return resultobj;
21833 fail:
21834 {
21835 if (temp3) delete arg3;
21836 }
21837 return NULL;
21838 }
21839
21840
21841 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21842 PyObject *resultobj;
21843 wxDateTime *arg1 = (wxDateTime *) 0 ;
21844 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21845 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21846 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21847 int result;
21848 bool temp3 = false ;
21849 PyObject * obj0 = 0 ;
21850 PyObject * obj1 = 0 ;
21851 PyObject * obj2 = 0 ;
21852 char *kwnames[] = {
21853 (char *) "self",(char *) "flags",(char *) "tz", NULL
21854 };
21855
21856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21858 if (SWIG_arg_fail(1)) SWIG_fail;
21859 if (obj1) {
21860 {
21861 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21862 if (SWIG_arg_fail(2)) SWIG_fail;
21863 }
21864 }
21865 if (obj2) {
21866 {
21867 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21868 temp3 = true;
21869 }
21870 }
21871 {
21872 PyThreadState* __tstate = wxPyBeginAllowThreads();
21873 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21874
21875 wxPyEndAllowThreads(__tstate);
21876 if (PyErr_Occurred()) SWIG_fail;
21877 }
21878 {
21879 resultobj = SWIG_From_int((int)(result));
21880 }
21881 {
21882 if (temp3) delete arg3;
21883 }
21884 return resultobj;
21885 fail:
21886 {
21887 if (temp3) delete arg3;
21888 }
21889 return NULL;
21890 }
21891
21892
21893 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21894 PyObject *resultobj;
21895 wxDateTime *arg1 = (wxDateTime *) 0 ;
21896 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21897 bool result;
21898 PyObject * obj0 = 0 ;
21899 PyObject * obj1 = 0 ;
21900 char *kwnames[] = {
21901 (char *) "self",(char *) "country", NULL
21902 };
21903
21904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21906 if (SWIG_arg_fail(1)) SWIG_fail;
21907 if (obj1) {
21908 {
21909 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21910 if (SWIG_arg_fail(2)) SWIG_fail;
21911 }
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21922 }
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21930 PyObject *resultobj;
21931 wxDateTime *arg1 = (wxDateTime *) 0 ;
21932 wxDateTime *arg2 = 0 ;
21933 bool result;
21934 PyObject * obj0 = 0 ;
21935 PyObject * obj1 = 0 ;
21936 char *kwnames[] = {
21937 (char *) "self",(char *) "datetime", NULL
21938 };
21939
21940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21942 if (SWIG_arg_fail(1)) SWIG_fail;
21943 {
21944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21945 if (SWIG_arg_fail(2)) SWIG_fail;
21946 if (arg2 == NULL) {
21947 SWIG_null_ref("wxDateTime");
21948 }
21949 if (SWIG_arg_fail(2)) SWIG_fail;
21950 }
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21954
21955 wxPyEndAllowThreads(__tstate);
21956 if (PyErr_Occurred()) SWIG_fail;
21957 }
21958 {
21959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21960 }
21961 return resultobj;
21962 fail:
21963 return NULL;
21964 }
21965
21966
21967 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj;
21969 wxDateTime *arg1 = (wxDateTime *) 0 ;
21970 wxDateTime *arg2 = 0 ;
21971 bool result;
21972 PyObject * obj0 = 0 ;
21973 PyObject * obj1 = 0 ;
21974 char *kwnames[] = {
21975 (char *) "self",(char *) "datetime", NULL
21976 };
21977
21978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21980 if (SWIG_arg_fail(1)) SWIG_fail;
21981 {
21982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21983 if (SWIG_arg_fail(2)) SWIG_fail;
21984 if (arg2 == NULL) {
21985 SWIG_null_ref("wxDateTime");
21986 }
21987 if (SWIG_arg_fail(2)) SWIG_fail;
21988 }
21989 {
21990 PyThreadState* __tstate = wxPyBeginAllowThreads();
21991 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
21992
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22006 PyObject *resultobj;
22007 wxDateTime *arg1 = (wxDateTime *) 0 ;
22008 wxDateTime *arg2 = 0 ;
22009 bool result;
22010 PyObject * obj0 = 0 ;
22011 PyObject * obj1 = 0 ;
22012 char *kwnames[] = {
22013 (char *) "self",(char *) "datetime", NULL
22014 };
22015
22016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22018 if (SWIG_arg_fail(1)) SWIG_fail;
22019 {
22020 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22021 if (SWIG_arg_fail(2)) SWIG_fail;
22022 if (arg2 == NULL) {
22023 SWIG_null_ref("wxDateTime");
22024 }
22025 if (SWIG_arg_fail(2)) SWIG_fail;
22026 }
22027 {
22028 PyThreadState* __tstate = wxPyBeginAllowThreads();
22029 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22030
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 {
22035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22036 }
22037 return resultobj;
22038 fail:
22039 return NULL;
22040 }
22041
22042
22043 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22044 PyObject *resultobj;
22045 wxDateTime *arg1 = (wxDateTime *) 0 ;
22046 wxDateTime *arg2 = 0 ;
22047 wxDateTime *arg3 = 0 ;
22048 bool result;
22049 PyObject * obj0 = 0 ;
22050 PyObject * obj1 = 0 ;
22051 PyObject * obj2 = 0 ;
22052 char *kwnames[] = {
22053 (char *) "self",(char *) "t1",(char *) "t2", NULL
22054 };
22055
22056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22058 if (SWIG_arg_fail(1)) SWIG_fail;
22059 {
22060 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22061 if (SWIG_arg_fail(2)) SWIG_fail;
22062 if (arg2 == NULL) {
22063 SWIG_null_ref("wxDateTime");
22064 }
22065 if (SWIG_arg_fail(2)) SWIG_fail;
22066 }
22067 {
22068 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22069 if (SWIG_arg_fail(3)) SWIG_fail;
22070 if (arg3 == NULL) {
22071 SWIG_null_ref("wxDateTime");
22072 }
22073 if (SWIG_arg_fail(3)) SWIG_fail;
22074 }
22075 {
22076 PyThreadState* __tstate = wxPyBeginAllowThreads();
22077 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22078
22079 wxPyEndAllowThreads(__tstate);
22080 if (PyErr_Occurred()) SWIG_fail;
22081 }
22082 {
22083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22084 }
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22092 PyObject *resultobj;
22093 wxDateTime *arg1 = (wxDateTime *) 0 ;
22094 wxDateTime *arg2 = 0 ;
22095 wxDateTime *arg3 = 0 ;
22096 bool result;
22097 PyObject * obj0 = 0 ;
22098 PyObject * obj1 = 0 ;
22099 PyObject * obj2 = 0 ;
22100 char *kwnames[] = {
22101 (char *) "self",(char *) "t1",(char *) "t2", NULL
22102 };
22103
22104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22106 if (SWIG_arg_fail(1)) SWIG_fail;
22107 {
22108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22109 if (SWIG_arg_fail(2)) SWIG_fail;
22110 if (arg2 == NULL) {
22111 SWIG_null_ref("wxDateTime");
22112 }
22113 if (SWIG_arg_fail(2)) SWIG_fail;
22114 }
22115 {
22116 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(3)) SWIG_fail;
22118 if (arg3 == NULL) {
22119 SWIG_null_ref("wxDateTime");
22120 }
22121 if (SWIG_arg_fail(3)) SWIG_fail;
22122 }
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22126
22127 wxPyEndAllowThreads(__tstate);
22128 if (PyErr_Occurred()) SWIG_fail;
22129 }
22130 {
22131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22132 }
22133 return resultobj;
22134 fail:
22135 return NULL;
22136 }
22137
22138
22139 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22140 PyObject *resultobj;
22141 wxDateTime *arg1 = (wxDateTime *) 0 ;
22142 wxDateTime *arg2 = 0 ;
22143 bool result;
22144 PyObject * obj0 = 0 ;
22145 PyObject * obj1 = 0 ;
22146 char *kwnames[] = {
22147 (char *) "self",(char *) "dt", NULL
22148 };
22149
22150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22152 if (SWIG_arg_fail(1)) SWIG_fail;
22153 {
22154 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22155 if (SWIG_arg_fail(2)) SWIG_fail;
22156 if (arg2 == NULL) {
22157 SWIG_null_ref("wxDateTime");
22158 }
22159 if (SWIG_arg_fail(2)) SWIG_fail;
22160 }
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22164
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj;
22179 wxDateTime *arg1 = (wxDateTime *) 0 ;
22180 wxDateTime *arg2 = 0 ;
22181 bool result;
22182 PyObject * obj0 = 0 ;
22183 PyObject * obj1 = 0 ;
22184 char *kwnames[] = {
22185 (char *) "self",(char *) "dt", NULL
22186 };
22187
22188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(1)) SWIG_fail;
22191 {
22192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22193 if (SWIG_arg_fail(2)) SWIG_fail;
22194 if (arg2 == NULL) {
22195 SWIG_null_ref("wxDateTime");
22196 }
22197 if (SWIG_arg_fail(2)) SWIG_fail;
22198 }
22199 {
22200 PyThreadState* __tstate = wxPyBeginAllowThreads();
22201 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22202
22203 wxPyEndAllowThreads(__tstate);
22204 if (PyErr_Occurred()) SWIG_fail;
22205 }
22206 {
22207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22208 }
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj;
22217 wxDateTime *arg1 = (wxDateTime *) 0 ;
22218 wxDateTime *arg2 = 0 ;
22219 wxTimeSpan *arg3 = 0 ;
22220 bool result;
22221 PyObject * obj0 = 0 ;
22222 PyObject * obj1 = 0 ;
22223 PyObject * obj2 = 0 ;
22224 char *kwnames[] = {
22225 (char *) "self",(char *) "dt",(char *) "ts", NULL
22226 };
22227
22228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22230 if (SWIG_arg_fail(1)) SWIG_fail;
22231 {
22232 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22233 if (SWIG_arg_fail(2)) SWIG_fail;
22234 if (arg2 == NULL) {
22235 SWIG_null_ref("wxDateTime");
22236 }
22237 if (SWIG_arg_fail(2)) SWIG_fail;
22238 }
22239 {
22240 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22241 if (SWIG_arg_fail(3)) SWIG_fail;
22242 if (arg3 == NULL) {
22243 SWIG_null_ref("wxTimeSpan");
22244 }
22245 if (SWIG_arg_fail(3)) SWIG_fail;
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 {
22255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22256 }
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj;
22265 wxDateTime *arg1 = (wxDateTime *) 0 ;
22266 wxTimeSpan *arg2 = 0 ;
22267 wxDateTime *result;
22268 PyObject * obj0 = 0 ;
22269 PyObject * obj1 = 0 ;
22270 char *kwnames[] = {
22271 (char *) "self",(char *) "diff", NULL
22272 };
22273
22274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22276 if (SWIG_arg_fail(1)) SWIG_fail;
22277 {
22278 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22279 if (SWIG_arg_fail(2)) SWIG_fail;
22280 if (arg2 == NULL) {
22281 SWIG_null_ref("wxTimeSpan");
22282 }
22283 if (SWIG_arg_fail(2)) SWIG_fail;
22284 }
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 {
22288 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22289 result = (wxDateTime *) &_result_ref;
22290 }
22291
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22303 PyObject *resultobj;
22304 wxDateTime *arg1 = (wxDateTime *) 0 ;
22305 wxDateSpan *arg2 = 0 ;
22306 wxDateTime *result;
22307 PyObject * obj0 = 0 ;
22308 PyObject * obj1 = 0 ;
22309 char *kwnames[] = {
22310 (char *) "self",(char *) "diff", NULL
22311 };
22312
22313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22315 if (SWIG_arg_fail(1)) SWIG_fail;
22316 {
22317 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22318 if (SWIG_arg_fail(2)) SWIG_fail;
22319 if (arg2 == NULL) {
22320 SWIG_null_ref("wxDateSpan");
22321 }
22322 if (SWIG_arg_fail(2)) SWIG_fail;
22323 }
22324 {
22325 PyThreadState* __tstate = wxPyBeginAllowThreads();
22326 {
22327 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22328 result = (wxDateTime *) &_result_ref;
22329 }
22330
22331 wxPyEndAllowThreads(__tstate);
22332 if (PyErr_Occurred()) SWIG_fail;
22333 }
22334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22335 return resultobj;
22336 fail:
22337 return NULL;
22338 }
22339
22340
22341 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22342 PyObject *resultobj;
22343 wxDateTime *arg1 = (wxDateTime *) 0 ;
22344 wxTimeSpan *arg2 = 0 ;
22345 wxDateTime *result;
22346 PyObject * obj0 = 0 ;
22347 PyObject * obj1 = 0 ;
22348 char *kwnames[] = {
22349 (char *) "self",(char *) "diff", NULL
22350 };
22351
22352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22354 if (SWIG_arg_fail(1)) SWIG_fail;
22355 {
22356 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22357 if (SWIG_arg_fail(2)) SWIG_fail;
22358 if (arg2 == NULL) {
22359 SWIG_null_ref("wxTimeSpan");
22360 }
22361 if (SWIG_arg_fail(2)) SWIG_fail;
22362 }
22363 {
22364 PyThreadState* __tstate = wxPyBeginAllowThreads();
22365 {
22366 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22367 result = (wxDateTime *) &_result_ref;
22368 }
22369
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22381 PyObject *resultobj;
22382 wxDateTime *arg1 = (wxDateTime *) 0 ;
22383 wxDateSpan *arg2 = 0 ;
22384 wxDateTime *result;
22385 PyObject * obj0 = 0 ;
22386 PyObject * obj1 = 0 ;
22387 char *kwnames[] = {
22388 (char *) "self",(char *) "diff", NULL
22389 };
22390
22391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22393 if (SWIG_arg_fail(1)) SWIG_fail;
22394 {
22395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22396 if (SWIG_arg_fail(2)) SWIG_fail;
22397 if (arg2 == NULL) {
22398 SWIG_null_ref("wxDateSpan");
22399 }
22400 if (SWIG_arg_fail(2)) SWIG_fail;
22401 }
22402 {
22403 PyThreadState* __tstate = wxPyBeginAllowThreads();
22404 {
22405 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22406 result = (wxDateTime *) &_result_ref;
22407 }
22408
22409 wxPyEndAllowThreads(__tstate);
22410 if (PyErr_Occurred()) SWIG_fail;
22411 }
22412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22413 return resultobj;
22414 fail:
22415 return NULL;
22416 }
22417
22418
22419 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22420 PyObject *resultobj;
22421 wxDateTime *arg1 = (wxDateTime *) 0 ;
22422 wxDateTime *arg2 = 0 ;
22423 wxTimeSpan result;
22424 PyObject * obj0 = 0 ;
22425 PyObject * obj1 = 0 ;
22426 char *kwnames[] = {
22427 (char *) "self",(char *) "dt", NULL
22428 };
22429
22430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22432 if (SWIG_arg_fail(1)) SWIG_fail;
22433 {
22434 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22435 if (SWIG_arg_fail(2)) SWIG_fail;
22436 if (arg2 == NULL) {
22437 SWIG_null_ref("wxDateTime");
22438 }
22439 if (SWIG_arg_fail(2)) SWIG_fail;
22440 }
22441 {
22442 PyThreadState* __tstate = wxPyBeginAllowThreads();
22443 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22444
22445 wxPyEndAllowThreads(__tstate);
22446 if (PyErr_Occurred()) SWIG_fail;
22447 }
22448 {
22449 wxTimeSpan * resultptr;
22450 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22451 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22452 }
22453 return resultobj;
22454 fail:
22455 return NULL;
22456 }
22457
22458
22459 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22460 PyObject *resultobj;
22461 wxDateTime *arg1 = (wxDateTime *) 0 ;
22462 wxTimeSpan *arg2 = 0 ;
22463 wxDateTime *result;
22464 PyObject * obj0 = 0 ;
22465 PyObject * obj1 = 0 ;
22466
22467 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22469 if (SWIG_arg_fail(1)) SWIG_fail;
22470 {
22471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22472 if (SWIG_arg_fail(2)) SWIG_fail;
22473 if (arg2 == NULL) {
22474 SWIG_null_ref("wxTimeSpan");
22475 }
22476 if (SWIG_arg_fail(2)) SWIG_fail;
22477 }
22478 {
22479 PyThreadState* __tstate = wxPyBeginAllowThreads();
22480 {
22481 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22482 result = (wxDateTime *) &_result_ref;
22483 }
22484
22485 wxPyEndAllowThreads(__tstate);
22486 if (PyErr_Occurred()) SWIG_fail;
22487 }
22488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22496 PyObject *resultobj;
22497 wxDateTime *arg1 = (wxDateTime *) 0 ;
22498 wxDateSpan *arg2 = 0 ;
22499 wxDateTime *result;
22500 PyObject * obj0 = 0 ;
22501 PyObject * obj1 = 0 ;
22502
22503 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22505 if (SWIG_arg_fail(1)) SWIG_fail;
22506 {
22507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22508 if (SWIG_arg_fail(2)) SWIG_fail;
22509 if (arg2 == NULL) {
22510 SWIG_null_ref("wxDateSpan");
22511 }
22512 if (SWIG_arg_fail(2)) SWIG_fail;
22513 }
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 {
22517 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22518 result = (wxDateTime *) &_result_ref;
22519 }
22520
22521 wxPyEndAllowThreads(__tstate);
22522 if (PyErr_Occurred()) SWIG_fail;
22523 }
22524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22532 int argc;
22533 PyObject *argv[3];
22534 int ii;
22535
22536 argc = PyObject_Length(args);
22537 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22538 argv[ii] = PyTuple_GetItem(args,ii);
22539 }
22540 if (argc == 2) {
22541 int _v;
22542 {
22543 void *ptr;
22544 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22545 _v = 0;
22546 PyErr_Clear();
22547 } else {
22548 _v = 1;
22549 }
22550 }
22551 if (_v) {
22552 {
22553 void *ptr = 0;
22554 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22555 _v = 0;
22556 PyErr_Clear();
22557 } else {
22558 _v = (ptr != 0);
22559 }
22560 }
22561 if (_v) {
22562 return _wrap_DateTime___iadd____SWIG_0(self,args);
22563 }
22564 }
22565 }
22566 if (argc == 2) {
22567 int _v;
22568 {
22569 void *ptr;
22570 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22571 _v = 0;
22572 PyErr_Clear();
22573 } else {
22574 _v = 1;
22575 }
22576 }
22577 if (_v) {
22578 {
22579 void *ptr = 0;
22580 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22581 _v = 0;
22582 PyErr_Clear();
22583 } else {
22584 _v = (ptr != 0);
22585 }
22586 }
22587 if (_v) {
22588 return _wrap_DateTime___iadd____SWIG_1(self,args);
22589 }
22590 }
22591 }
22592
22593 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22599 PyObject *resultobj;
22600 wxDateTime *arg1 = (wxDateTime *) 0 ;
22601 wxTimeSpan *arg2 = 0 ;
22602 wxDateTime *result;
22603 PyObject * obj0 = 0 ;
22604 PyObject * obj1 = 0 ;
22605
22606 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22608 if (SWIG_arg_fail(1)) SWIG_fail;
22609 {
22610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22611 if (SWIG_arg_fail(2)) SWIG_fail;
22612 if (arg2 == NULL) {
22613 SWIG_null_ref("wxTimeSpan");
22614 }
22615 if (SWIG_arg_fail(2)) SWIG_fail;
22616 }
22617 {
22618 PyThreadState* __tstate = wxPyBeginAllowThreads();
22619 {
22620 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22621 result = (wxDateTime *) &_result_ref;
22622 }
22623
22624 wxPyEndAllowThreads(__tstate);
22625 if (PyErr_Occurred()) SWIG_fail;
22626 }
22627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22628 return resultobj;
22629 fail:
22630 return NULL;
22631 }
22632
22633
22634 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22635 PyObject *resultobj;
22636 wxDateTime *arg1 = (wxDateTime *) 0 ;
22637 wxDateSpan *arg2 = 0 ;
22638 wxDateTime *result;
22639 PyObject * obj0 = 0 ;
22640 PyObject * obj1 = 0 ;
22641
22642 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22644 if (SWIG_arg_fail(1)) SWIG_fail;
22645 {
22646 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22647 if (SWIG_arg_fail(2)) SWIG_fail;
22648 if (arg2 == NULL) {
22649 SWIG_null_ref("wxDateSpan");
22650 }
22651 if (SWIG_arg_fail(2)) SWIG_fail;
22652 }
22653 {
22654 PyThreadState* __tstate = wxPyBeginAllowThreads();
22655 {
22656 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22657 result = (wxDateTime *) &_result_ref;
22658 }
22659
22660 wxPyEndAllowThreads(__tstate);
22661 if (PyErr_Occurred()) SWIG_fail;
22662 }
22663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22664 return resultobj;
22665 fail:
22666 return NULL;
22667 }
22668
22669
22670 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22671 int argc;
22672 PyObject *argv[3];
22673 int ii;
22674
22675 argc = PyObject_Length(args);
22676 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22677 argv[ii] = PyTuple_GetItem(args,ii);
22678 }
22679 if (argc == 2) {
22680 int _v;
22681 {
22682 void *ptr;
22683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22684 _v = 0;
22685 PyErr_Clear();
22686 } else {
22687 _v = 1;
22688 }
22689 }
22690 if (_v) {
22691 {
22692 void *ptr = 0;
22693 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22694 _v = 0;
22695 PyErr_Clear();
22696 } else {
22697 _v = (ptr != 0);
22698 }
22699 }
22700 if (_v) {
22701 return _wrap_DateTime___isub____SWIG_0(self,args);
22702 }
22703 }
22704 }
22705 if (argc == 2) {
22706 int _v;
22707 {
22708 void *ptr;
22709 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22710 _v = 0;
22711 PyErr_Clear();
22712 } else {
22713 _v = 1;
22714 }
22715 }
22716 if (_v) {
22717 {
22718 void *ptr = 0;
22719 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22720 _v = 0;
22721 PyErr_Clear();
22722 } else {
22723 _v = (ptr != 0);
22724 }
22725 }
22726 if (_v) {
22727 return _wrap_DateTime___isub____SWIG_1(self,args);
22728 }
22729 }
22730 }
22731
22732 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22733 return NULL;
22734 }
22735
22736
22737 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22738 PyObject *resultobj;
22739 wxDateTime *arg1 = (wxDateTime *) 0 ;
22740 wxTimeSpan *arg2 = 0 ;
22741 wxDateTime result;
22742 PyObject * obj0 = 0 ;
22743 PyObject * obj1 = 0 ;
22744
22745 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22747 if (SWIG_arg_fail(1)) SWIG_fail;
22748 {
22749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22750 if (SWIG_arg_fail(2)) SWIG_fail;
22751 if (arg2 == NULL) {
22752 SWIG_null_ref("wxTimeSpan");
22753 }
22754 if (SWIG_arg_fail(2)) SWIG_fail;
22755 }
22756 {
22757 PyThreadState* __tstate = wxPyBeginAllowThreads();
22758 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22759
22760 wxPyEndAllowThreads(__tstate);
22761 if (PyErr_Occurred()) SWIG_fail;
22762 }
22763 {
22764 wxDateTime * resultptr;
22765 resultptr = new wxDateTime((wxDateTime &)(result));
22766 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22767 }
22768 return resultobj;
22769 fail:
22770 return NULL;
22771 }
22772
22773
22774 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22775 PyObject *resultobj;
22776 wxDateTime *arg1 = (wxDateTime *) 0 ;
22777 wxDateSpan *arg2 = 0 ;
22778 wxDateTime result;
22779 PyObject * obj0 = 0 ;
22780 PyObject * obj1 = 0 ;
22781
22782 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(1)) SWIG_fail;
22785 {
22786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22787 if (SWIG_arg_fail(2)) SWIG_fail;
22788 if (arg2 == NULL) {
22789 SWIG_null_ref("wxDateSpan");
22790 }
22791 if (SWIG_arg_fail(2)) SWIG_fail;
22792 }
22793 {
22794 PyThreadState* __tstate = wxPyBeginAllowThreads();
22795 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22796
22797 wxPyEndAllowThreads(__tstate);
22798 if (PyErr_Occurred()) SWIG_fail;
22799 }
22800 {
22801 wxDateTime * resultptr;
22802 resultptr = new wxDateTime((wxDateTime &)(result));
22803 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22804 }
22805 return resultobj;
22806 fail:
22807 return NULL;
22808 }
22809
22810
22811 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22812 int argc;
22813 PyObject *argv[3];
22814 int ii;
22815
22816 argc = PyObject_Length(args);
22817 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22818 argv[ii] = PyTuple_GetItem(args,ii);
22819 }
22820 if (argc == 2) {
22821 int _v;
22822 {
22823 void *ptr;
22824 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22825 _v = 0;
22826 PyErr_Clear();
22827 } else {
22828 _v = 1;
22829 }
22830 }
22831 if (_v) {
22832 {
22833 void *ptr = 0;
22834 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22835 _v = 0;
22836 PyErr_Clear();
22837 } else {
22838 _v = (ptr != 0);
22839 }
22840 }
22841 if (_v) {
22842 return _wrap_DateTime___add____SWIG_0(self,args);
22843 }
22844 }
22845 }
22846 if (argc == 2) {
22847 int _v;
22848 {
22849 void *ptr;
22850 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22851 _v = 0;
22852 PyErr_Clear();
22853 } else {
22854 _v = 1;
22855 }
22856 }
22857 if (_v) {
22858 {
22859 void *ptr = 0;
22860 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22861 _v = 0;
22862 PyErr_Clear();
22863 } else {
22864 _v = (ptr != 0);
22865 }
22866 }
22867 if (_v) {
22868 return _wrap_DateTime___add____SWIG_1(self,args);
22869 }
22870 }
22871 }
22872
22873 Py_INCREF(Py_NotImplemented);
22874 return Py_NotImplemented;
22875 }
22876
22877
22878 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22879 PyObject *resultobj;
22880 wxDateTime *arg1 = (wxDateTime *) 0 ;
22881 wxDateTime *arg2 = 0 ;
22882 wxTimeSpan result;
22883 PyObject * obj0 = 0 ;
22884 PyObject * obj1 = 0 ;
22885
22886 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22888 if (SWIG_arg_fail(1)) SWIG_fail;
22889 {
22890 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22891 if (SWIG_arg_fail(2)) SWIG_fail;
22892 if (arg2 == NULL) {
22893 SWIG_null_ref("wxDateTime");
22894 }
22895 if (SWIG_arg_fail(2)) SWIG_fail;
22896 }
22897 {
22898 PyThreadState* __tstate = wxPyBeginAllowThreads();
22899 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22900
22901 wxPyEndAllowThreads(__tstate);
22902 if (PyErr_Occurred()) SWIG_fail;
22903 }
22904 {
22905 wxTimeSpan * resultptr;
22906 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22907 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22908 }
22909 return resultobj;
22910 fail:
22911 return NULL;
22912 }
22913
22914
22915 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22916 PyObject *resultobj;
22917 wxDateTime *arg1 = (wxDateTime *) 0 ;
22918 wxTimeSpan *arg2 = 0 ;
22919 wxDateTime result;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922
22923 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22925 if (SWIG_arg_fail(1)) SWIG_fail;
22926 {
22927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22928 if (SWIG_arg_fail(2)) SWIG_fail;
22929 if (arg2 == NULL) {
22930 SWIG_null_ref("wxTimeSpan");
22931 }
22932 if (SWIG_arg_fail(2)) SWIG_fail;
22933 }
22934 {
22935 PyThreadState* __tstate = wxPyBeginAllowThreads();
22936 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22937
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 {
22942 wxDateTime * resultptr;
22943 resultptr = new wxDateTime((wxDateTime &)(result));
22944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22945 }
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22953 PyObject *resultobj;
22954 wxDateTime *arg1 = (wxDateTime *) 0 ;
22955 wxDateSpan *arg2 = 0 ;
22956 wxDateTime result;
22957 PyObject * obj0 = 0 ;
22958 PyObject * obj1 = 0 ;
22959
22960 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22962 if (SWIG_arg_fail(1)) SWIG_fail;
22963 {
22964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22965 if (SWIG_arg_fail(2)) SWIG_fail;
22966 if (arg2 == NULL) {
22967 SWIG_null_ref("wxDateSpan");
22968 }
22969 if (SWIG_arg_fail(2)) SWIG_fail;
22970 }
22971 {
22972 PyThreadState* __tstate = wxPyBeginAllowThreads();
22973 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22974
22975 wxPyEndAllowThreads(__tstate);
22976 if (PyErr_Occurred()) SWIG_fail;
22977 }
22978 {
22979 wxDateTime * resultptr;
22980 resultptr = new wxDateTime((wxDateTime &)(result));
22981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22982 }
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
22990 int argc;
22991 PyObject *argv[3];
22992 int ii;
22993
22994 argc = PyObject_Length(args);
22995 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22996 argv[ii] = PyTuple_GetItem(args,ii);
22997 }
22998 if (argc == 2) {
22999 int _v;
23000 {
23001 void *ptr;
23002 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23003 _v = 0;
23004 PyErr_Clear();
23005 } else {
23006 _v = 1;
23007 }
23008 }
23009 if (_v) {
23010 {
23011 void *ptr = 0;
23012 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23013 _v = 0;
23014 PyErr_Clear();
23015 } else {
23016 _v = (ptr != 0);
23017 }
23018 }
23019 if (_v) {
23020 return _wrap_DateTime___sub____SWIG_0(self,args);
23021 }
23022 }
23023 }
23024 if (argc == 2) {
23025 int _v;
23026 {
23027 void *ptr;
23028 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23029 _v = 0;
23030 PyErr_Clear();
23031 } else {
23032 _v = 1;
23033 }
23034 }
23035 if (_v) {
23036 {
23037 void *ptr = 0;
23038 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23039 _v = 0;
23040 PyErr_Clear();
23041 } else {
23042 _v = (ptr != 0);
23043 }
23044 }
23045 if (_v) {
23046 return _wrap_DateTime___sub____SWIG_1(self,args);
23047 }
23048 }
23049 }
23050 if (argc == 2) {
23051 int _v;
23052 {
23053 void *ptr;
23054 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23055 _v = 0;
23056 PyErr_Clear();
23057 } else {
23058 _v = 1;
23059 }
23060 }
23061 if (_v) {
23062 {
23063 void *ptr = 0;
23064 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23065 _v = 0;
23066 PyErr_Clear();
23067 } else {
23068 _v = (ptr != 0);
23069 }
23070 }
23071 if (_v) {
23072 return _wrap_DateTime___sub____SWIG_2(self,args);
23073 }
23074 }
23075 }
23076
23077 Py_INCREF(Py_NotImplemented);
23078 return Py_NotImplemented;
23079 }
23080
23081
23082 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23083 PyObject *resultobj;
23084 wxDateTime *arg1 = (wxDateTime *) 0 ;
23085 wxDateTime *arg2 = (wxDateTime *) 0 ;
23086 bool result;
23087 PyObject * obj0 = 0 ;
23088 PyObject * obj1 = 0 ;
23089 char *kwnames[] = {
23090 (char *) "self",(char *) "other", NULL
23091 };
23092
23093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23095 if (SWIG_arg_fail(1)) SWIG_fail;
23096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23097 if (SWIG_arg_fail(2)) SWIG_fail;
23098 {
23099 PyThreadState* __tstate = wxPyBeginAllowThreads();
23100 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23101
23102 wxPyEndAllowThreads(__tstate);
23103 if (PyErr_Occurred()) SWIG_fail;
23104 }
23105 {
23106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23107 }
23108 return resultobj;
23109 fail:
23110 return NULL;
23111 }
23112
23113
23114 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23115 PyObject *resultobj;
23116 wxDateTime *arg1 = (wxDateTime *) 0 ;
23117 wxDateTime *arg2 = (wxDateTime *) 0 ;
23118 bool result;
23119 PyObject * obj0 = 0 ;
23120 PyObject * obj1 = 0 ;
23121 char *kwnames[] = {
23122 (char *) "self",(char *) "other", NULL
23123 };
23124
23125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23127 if (SWIG_arg_fail(1)) SWIG_fail;
23128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23129 if (SWIG_arg_fail(2)) SWIG_fail;
23130 {
23131 PyThreadState* __tstate = wxPyBeginAllowThreads();
23132 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23133
23134 wxPyEndAllowThreads(__tstate);
23135 if (PyErr_Occurred()) SWIG_fail;
23136 }
23137 {
23138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23139 }
23140 return resultobj;
23141 fail:
23142 return NULL;
23143 }
23144
23145
23146 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23147 PyObject *resultobj;
23148 wxDateTime *arg1 = (wxDateTime *) 0 ;
23149 wxDateTime *arg2 = (wxDateTime *) 0 ;
23150 bool result;
23151 PyObject * obj0 = 0 ;
23152 PyObject * obj1 = 0 ;
23153 char *kwnames[] = {
23154 (char *) "self",(char *) "other", NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23159 if (SWIG_arg_fail(1)) SWIG_fail;
23160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23161 if (SWIG_arg_fail(2)) SWIG_fail;
23162 {
23163 PyThreadState* __tstate = wxPyBeginAllowThreads();
23164 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23165
23166 wxPyEndAllowThreads(__tstate);
23167 if (PyErr_Occurred()) SWIG_fail;
23168 }
23169 {
23170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23171 }
23172 return resultobj;
23173 fail:
23174 return NULL;
23175 }
23176
23177
23178 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23179 PyObject *resultobj;
23180 wxDateTime *arg1 = (wxDateTime *) 0 ;
23181 wxDateTime *arg2 = (wxDateTime *) 0 ;
23182 bool result;
23183 PyObject * obj0 = 0 ;
23184 PyObject * obj1 = 0 ;
23185 char *kwnames[] = {
23186 (char *) "self",(char *) "other", NULL
23187 };
23188
23189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23191 if (SWIG_arg_fail(1)) SWIG_fail;
23192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23193 if (SWIG_arg_fail(2)) SWIG_fail;
23194 {
23195 PyThreadState* __tstate = wxPyBeginAllowThreads();
23196 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23197
23198 wxPyEndAllowThreads(__tstate);
23199 if (PyErr_Occurred()) SWIG_fail;
23200 }
23201 {
23202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23203 }
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23211 PyObject *resultobj;
23212 wxDateTime *arg1 = (wxDateTime *) 0 ;
23213 wxDateTime *arg2 = (wxDateTime *) 0 ;
23214 bool result;
23215 PyObject * obj0 = 0 ;
23216 PyObject * obj1 = 0 ;
23217 char *kwnames[] = {
23218 (char *) "self",(char *) "other", NULL
23219 };
23220
23221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23223 if (SWIG_arg_fail(1)) SWIG_fail;
23224 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(2)) SWIG_fail;
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23229
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23243 PyObject *resultobj;
23244 wxDateTime *arg1 = (wxDateTime *) 0 ;
23245 wxDateTime *arg2 = (wxDateTime *) 0 ;
23246 bool result;
23247 PyObject * obj0 = 0 ;
23248 PyObject * obj1 = 0 ;
23249 char *kwnames[] = {
23250 (char *) "self",(char *) "other", NULL
23251 };
23252
23253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23255 if (SWIG_arg_fail(1)) SWIG_fail;
23256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23257 if (SWIG_arg_fail(2)) SWIG_fail;
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 wxDateTime *arg1 = (wxDateTime *) 0 ;
23277 wxString *arg2 = 0 ;
23278 int result;
23279 bool temp2 = false ;
23280 PyObject * obj0 = 0 ;
23281 PyObject * obj1 = 0 ;
23282 char *kwnames[] = {
23283 (char *) "self",(char *) "date", NULL
23284 };
23285
23286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(1)) SWIG_fail;
23289 {
23290 arg2 = wxString_in_helper(obj1);
23291 if (arg2 == NULL) SWIG_fail;
23292 temp2 = true;
23293 }
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23297
23298 wxPyEndAllowThreads(__tstate);
23299 if (PyErr_Occurred()) SWIG_fail;
23300 }
23301 {
23302 resultobj = SWIG_From_int((int)(result));
23303 }
23304 {
23305 if (temp2)
23306 delete arg2;
23307 }
23308 return resultobj;
23309 fail:
23310 {
23311 if (temp2)
23312 delete arg2;
23313 }
23314 return NULL;
23315 }
23316
23317
23318 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23319 PyObject *resultobj;
23320 wxDateTime *arg1 = (wxDateTime *) 0 ;
23321 wxString *arg2 = 0 ;
23322 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23323 wxString *arg3 = (wxString *) &arg3_defvalue ;
23324 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23325 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23326 int result;
23327 bool temp2 = false ;
23328 bool temp3 = false ;
23329 PyObject * obj0 = 0 ;
23330 PyObject * obj1 = 0 ;
23331 PyObject * obj2 = 0 ;
23332 PyObject * obj3 = 0 ;
23333 char *kwnames[] = {
23334 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23335 };
23336
23337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23339 if (SWIG_arg_fail(1)) SWIG_fail;
23340 {
23341 arg2 = wxString_in_helper(obj1);
23342 if (arg2 == NULL) SWIG_fail;
23343 temp2 = true;
23344 }
23345 if (obj2) {
23346 {
23347 arg3 = wxString_in_helper(obj2);
23348 if (arg3 == NULL) SWIG_fail;
23349 temp3 = true;
23350 }
23351 }
23352 if (obj3) {
23353 {
23354 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23355 if (SWIG_arg_fail(4)) SWIG_fail;
23356 if (arg4 == NULL) {
23357 SWIG_null_ref("wxDateTime");
23358 }
23359 if (SWIG_arg_fail(4)) SWIG_fail;
23360 }
23361 }
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23365
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 {
23370 resultobj = SWIG_From_int((int)(result));
23371 }
23372 {
23373 if (temp2)
23374 delete arg2;
23375 }
23376 {
23377 if (temp3)
23378 delete arg3;
23379 }
23380 return resultobj;
23381 fail:
23382 {
23383 if (temp2)
23384 delete arg2;
23385 }
23386 {
23387 if (temp3)
23388 delete arg3;
23389 }
23390 return NULL;
23391 }
23392
23393
23394 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23395 PyObject *resultobj;
23396 wxDateTime *arg1 = (wxDateTime *) 0 ;
23397 wxString *arg2 = 0 ;
23398 int result;
23399 bool temp2 = false ;
23400 PyObject * obj0 = 0 ;
23401 PyObject * obj1 = 0 ;
23402 char *kwnames[] = {
23403 (char *) "self",(char *) "datetime", NULL
23404 };
23405
23406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23408 if (SWIG_arg_fail(1)) SWIG_fail;
23409 {
23410 arg2 = wxString_in_helper(obj1);
23411 if (arg2 == NULL) SWIG_fail;
23412 temp2 = true;
23413 }
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23417
23418 wxPyEndAllowThreads(__tstate);
23419 if (PyErr_Occurred()) SWIG_fail;
23420 }
23421 {
23422 resultobj = SWIG_From_int((int)(result));
23423 }
23424 {
23425 if (temp2)
23426 delete arg2;
23427 }
23428 return resultobj;
23429 fail:
23430 {
23431 if (temp2)
23432 delete arg2;
23433 }
23434 return NULL;
23435 }
23436
23437
23438 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23439 PyObject *resultobj;
23440 wxDateTime *arg1 = (wxDateTime *) 0 ;
23441 wxString *arg2 = 0 ;
23442 int result;
23443 bool temp2 = false ;
23444 PyObject * obj0 = 0 ;
23445 PyObject * obj1 = 0 ;
23446 char *kwnames[] = {
23447 (char *) "self",(char *) "date", NULL
23448 };
23449
23450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23452 if (SWIG_arg_fail(1)) SWIG_fail;
23453 {
23454 arg2 = wxString_in_helper(obj1);
23455 if (arg2 == NULL) SWIG_fail;
23456 temp2 = true;
23457 }
23458 {
23459 PyThreadState* __tstate = wxPyBeginAllowThreads();
23460 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23461
23462 wxPyEndAllowThreads(__tstate);
23463 if (PyErr_Occurred()) SWIG_fail;
23464 }
23465 {
23466 resultobj = SWIG_From_int((int)(result));
23467 }
23468 {
23469 if (temp2)
23470 delete arg2;
23471 }
23472 return resultobj;
23473 fail:
23474 {
23475 if (temp2)
23476 delete arg2;
23477 }
23478 return NULL;
23479 }
23480
23481
23482 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23483 PyObject *resultobj;
23484 wxDateTime *arg1 = (wxDateTime *) 0 ;
23485 wxString *arg2 = 0 ;
23486 int result;
23487 bool temp2 = false ;
23488 PyObject * obj0 = 0 ;
23489 PyObject * obj1 = 0 ;
23490 char *kwnames[] = {
23491 (char *) "self",(char *) "time", NULL
23492 };
23493
23494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23496 if (SWIG_arg_fail(1)) SWIG_fail;
23497 {
23498 arg2 = wxString_in_helper(obj1);
23499 if (arg2 == NULL) SWIG_fail;
23500 temp2 = true;
23501 }
23502 {
23503 PyThreadState* __tstate = wxPyBeginAllowThreads();
23504 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23505
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 {
23510 resultobj = SWIG_From_int((int)(result));
23511 }
23512 {
23513 if (temp2)
23514 delete arg2;
23515 }
23516 return resultobj;
23517 fail:
23518 {
23519 if (temp2)
23520 delete arg2;
23521 }
23522 return NULL;
23523 }
23524
23525
23526 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23527 PyObject *resultobj;
23528 wxDateTime *arg1 = (wxDateTime *) 0 ;
23529 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23530 wxString *arg2 = (wxString *) &arg2_defvalue ;
23531 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23532 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23533 wxString result;
23534 bool temp2 = false ;
23535 bool temp3 = false ;
23536 PyObject * obj0 = 0 ;
23537 PyObject * obj1 = 0 ;
23538 PyObject * obj2 = 0 ;
23539 char *kwnames[] = {
23540 (char *) "self",(char *) "format",(char *) "tz", NULL
23541 };
23542
23543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23545 if (SWIG_arg_fail(1)) SWIG_fail;
23546 if (obj1) {
23547 {
23548 arg2 = wxString_in_helper(obj1);
23549 if (arg2 == NULL) SWIG_fail;
23550 temp2 = true;
23551 }
23552 }
23553 if (obj2) {
23554 {
23555 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23556 temp3 = true;
23557 }
23558 }
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23562
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 {
23567 #if wxUSE_UNICODE
23568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23569 #else
23570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23571 #endif
23572 }
23573 {
23574 if (temp2)
23575 delete arg2;
23576 }
23577 {
23578 if (temp3) delete arg3;
23579 }
23580 return resultobj;
23581 fail:
23582 {
23583 if (temp2)
23584 delete arg2;
23585 }
23586 {
23587 if (temp3) delete arg3;
23588 }
23589 return NULL;
23590 }
23591
23592
23593 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23594 PyObject *resultobj;
23595 wxDateTime *arg1 = (wxDateTime *) 0 ;
23596 wxString result;
23597 PyObject * obj0 = 0 ;
23598 char *kwnames[] = {
23599 (char *) "self", NULL
23600 };
23601
23602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23604 if (SWIG_arg_fail(1)) SWIG_fail;
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = ((wxDateTime const *)arg1)->FormatDate();
23608
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 #if wxUSE_UNICODE
23614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23615 #else
23616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23617 #endif
23618 }
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj;
23627 wxDateTime *arg1 = (wxDateTime *) 0 ;
23628 wxString result;
23629 PyObject * obj0 = 0 ;
23630 char *kwnames[] = {
23631 (char *) "self", NULL
23632 };
23633
23634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23636 if (SWIG_arg_fail(1)) SWIG_fail;
23637 {
23638 PyThreadState* __tstate = wxPyBeginAllowThreads();
23639 result = ((wxDateTime const *)arg1)->FormatTime();
23640
23641 wxPyEndAllowThreads(__tstate);
23642 if (PyErr_Occurred()) SWIG_fail;
23643 }
23644 {
23645 #if wxUSE_UNICODE
23646 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23647 #else
23648 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23649 #endif
23650 }
23651 return resultobj;
23652 fail:
23653 return NULL;
23654 }
23655
23656
23657 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23658 PyObject *resultobj;
23659 wxDateTime *arg1 = (wxDateTime *) 0 ;
23660 wxString result;
23661 PyObject * obj0 = 0 ;
23662 char *kwnames[] = {
23663 (char *) "self", NULL
23664 };
23665
23666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23668 if (SWIG_arg_fail(1)) SWIG_fail;
23669 {
23670 PyThreadState* __tstate = wxPyBeginAllowThreads();
23671 result = ((wxDateTime const *)arg1)->FormatISODate();
23672
23673 wxPyEndAllowThreads(__tstate);
23674 if (PyErr_Occurred()) SWIG_fail;
23675 }
23676 {
23677 #if wxUSE_UNICODE
23678 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23679 #else
23680 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23681 #endif
23682 }
23683 return resultobj;
23684 fail:
23685 return NULL;
23686 }
23687
23688
23689 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23690 PyObject *resultobj;
23691 wxDateTime *arg1 = (wxDateTime *) 0 ;
23692 wxString result;
23693 PyObject * obj0 = 0 ;
23694 char *kwnames[] = {
23695 (char *) "self", NULL
23696 };
23697
23698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23700 if (SWIG_arg_fail(1)) SWIG_fail;
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = ((wxDateTime const *)arg1)->FormatISOTime();
23704
23705 wxPyEndAllowThreads(__tstate);
23706 if (PyErr_Occurred()) SWIG_fail;
23707 }
23708 {
23709 #if wxUSE_UNICODE
23710 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23711 #else
23712 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23713 #endif
23714 }
23715 return resultobj;
23716 fail:
23717 return NULL;
23718 }
23719
23720
23721 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23722 PyObject *obj;
23723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23724 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23725 Py_INCREF(obj);
23726 return Py_BuildValue((char *)"");
23727 }
23728 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23729 PyObject *resultobj;
23730 long arg1 ;
23731 wxTimeSpan result;
23732 PyObject * obj0 = 0 ;
23733 char *kwnames[] = {
23734 (char *) "sec", NULL
23735 };
23736
23737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23738 {
23739 arg1 = (long)(SWIG_As_long(obj0));
23740 if (SWIG_arg_fail(1)) SWIG_fail;
23741 }
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = wxTimeSpan::Seconds(arg1);
23745
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 {
23750 wxTimeSpan * resultptr;
23751 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23752 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23753 }
23754 return resultobj;
23755 fail:
23756 return NULL;
23757 }
23758
23759
23760 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23761 PyObject *resultobj;
23762 wxTimeSpan result;
23763 char *kwnames[] = {
23764 NULL
23765 };
23766
23767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = wxTimeSpan::Second();
23771
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 {
23776 wxTimeSpan * resultptr;
23777 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23779 }
23780 return resultobj;
23781 fail:
23782 return NULL;
23783 }
23784
23785
23786 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23787 PyObject *resultobj;
23788 long arg1 ;
23789 wxTimeSpan result;
23790 PyObject * obj0 = 0 ;
23791 char *kwnames[] = {
23792 (char *) "min", NULL
23793 };
23794
23795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23796 {
23797 arg1 = (long)(SWIG_As_long(obj0));
23798 if (SWIG_arg_fail(1)) SWIG_fail;
23799 }
23800 {
23801 PyThreadState* __tstate = wxPyBeginAllowThreads();
23802 result = wxTimeSpan::Minutes(arg1);
23803
23804 wxPyEndAllowThreads(__tstate);
23805 if (PyErr_Occurred()) SWIG_fail;
23806 }
23807 {
23808 wxTimeSpan * resultptr;
23809 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23811 }
23812 return resultobj;
23813 fail:
23814 return NULL;
23815 }
23816
23817
23818 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj;
23820 wxTimeSpan result;
23821 char *kwnames[] = {
23822 NULL
23823 };
23824
23825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = wxTimeSpan::Minute();
23829
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 {
23834 wxTimeSpan * resultptr;
23835 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23836 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23837 }
23838 return resultobj;
23839 fail:
23840 return NULL;
23841 }
23842
23843
23844 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23845 PyObject *resultobj;
23846 long arg1 ;
23847 wxTimeSpan result;
23848 PyObject * obj0 = 0 ;
23849 char *kwnames[] = {
23850 (char *) "hours", NULL
23851 };
23852
23853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23854 {
23855 arg1 = (long)(SWIG_As_long(obj0));
23856 if (SWIG_arg_fail(1)) SWIG_fail;
23857 }
23858 {
23859 PyThreadState* __tstate = wxPyBeginAllowThreads();
23860 result = wxTimeSpan::Hours(arg1);
23861
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 {
23866 wxTimeSpan * resultptr;
23867 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23868 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23869 }
23870 return resultobj;
23871 fail:
23872 return NULL;
23873 }
23874
23875
23876 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23877 PyObject *resultobj;
23878 wxTimeSpan result;
23879 char *kwnames[] = {
23880 NULL
23881 };
23882
23883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23884 {
23885 PyThreadState* __tstate = wxPyBeginAllowThreads();
23886 result = wxTimeSpan::Hour();
23887
23888 wxPyEndAllowThreads(__tstate);
23889 if (PyErr_Occurred()) SWIG_fail;
23890 }
23891 {
23892 wxTimeSpan * resultptr;
23893 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23895 }
23896 return resultobj;
23897 fail:
23898 return NULL;
23899 }
23900
23901
23902 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23903 PyObject *resultobj;
23904 long arg1 ;
23905 wxTimeSpan result;
23906 PyObject * obj0 = 0 ;
23907 char *kwnames[] = {
23908 (char *) "days", NULL
23909 };
23910
23911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23912 {
23913 arg1 = (long)(SWIG_As_long(obj0));
23914 if (SWIG_arg_fail(1)) SWIG_fail;
23915 }
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 result = wxTimeSpan::Days(arg1);
23919
23920 wxPyEndAllowThreads(__tstate);
23921 if (PyErr_Occurred()) SWIG_fail;
23922 }
23923 {
23924 wxTimeSpan * resultptr;
23925 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23926 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23927 }
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23935 PyObject *resultobj;
23936 wxTimeSpan result;
23937 char *kwnames[] = {
23938 NULL
23939 };
23940
23941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23942 {
23943 PyThreadState* __tstate = wxPyBeginAllowThreads();
23944 result = wxTimeSpan::Day();
23945
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 {
23950 wxTimeSpan * resultptr;
23951 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23953 }
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 long arg1 ;
23963 wxTimeSpan result;
23964 PyObject * obj0 = 0 ;
23965 char *kwnames[] = {
23966 (char *) "days", NULL
23967 };
23968
23969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23970 {
23971 arg1 = (long)(SWIG_As_long(obj0));
23972 if (SWIG_arg_fail(1)) SWIG_fail;
23973 }
23974 {
23975 PyThreadState* __tstate = wxPyBeginAllowThreads();
23976 result = wxTimeSpan::Weeks(arg1);
23977
23978 wxPyEndAllowThreads(__tstate);
23979 if (PyErr_Occurred()) SWIG_fail;
23980 }
23981 {
23982 wxTimeSpan * resultptr;
23983 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23985 }
23986 return resultobj;
23987 fail:
23988 return NULL;
23989 }
23990
23991
23992 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
23993 PyObject *resultobj;
23994 wxTimeSpan result;
23995 char *kwnames[] = {
23996 NULL
23997 };
23998
23999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24000 {
24001 PyThreadState* __tstate = wxPyBeginAllowThreads();
24002 result = wxTimeSpan::Week();
24003
24004 wxPyEndAllowThreads(__tstate);
24005 if (PyErr_Occurred()) SWIG_fail;
24006 }
24007 {
24008 wxTimeSpan * resultptr;
24009 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24010 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24011 }
24012 return resultobj;
24013 fail:
24014 return NULL;
24015 }
24016
24017
24018 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24019 PyObject *resultobj;
24020 long arg1 = (long) 0 ;
24021 long arg2 = (long) 0 ;
24022 long arg3 = (long) 0 ;
24023 long arg4 = (long) 0 ;
24024 wxTimeSpan *result;
24025 PyObject * obj0 = 0 ;
24026 PyObject * obj1 = 0 ;
24027 PyObject * obj2 = 0 ;
24028 PyObject * obj3 = 0 ;
24029 char *kwnames[] = {
24030 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24031 };
24032
24033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24034 if (obj0) {
24035 {
24036 arg1 = (long)(SWIG_As_long(obj0));
24037 if (SWIG_arg_fail(1)) SWIG_fail;
24038 }
24039 }
24040 if (obj1) {
24041 {
24042 arg2 = (long)(SWIG_As_long(obj1));
24043 if (SWIG_arg_fail(2)) SWIG_fail;
24044 }
24045 }
24046 if (obj2) {
24047 {
24048 arg3 = (long)(SWIG_As_long(obj2));
24049 if (SWIG_arg_fail(3)) SWIG_fail;
24050 }
24051 }
24052 if (obj3) {
24053 {
24054 arg4 = (long)(SWIG_As_long(obj3));
24055 if (SWIG_arg_fail(4)) SWIG_fail;
24056 }
24057 }
24058 {
24059 PyThreadState* __tstate = wxPyBeginAllowThreads();
24060 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24061
24062 wxPyEndAllowThreads(__tstate);
24063 if (PyErr_Occurred()) SWIG_fail;
24064 }
24065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24066 return resultobj;
24067 fail:
24068 return NULL;
24069 }
24070
24071
24072 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24073 PyObject *resultobj;
24074 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24075 PyObject * obj0 = 0 ;
24076 char *kwnames[] = {
24077 (char *) "self", NULL
24078 };
24079
24080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24082 if (SWIG_arg_fail(1)) SWIG_fail;
24083 {
24084 PyThreadState* __tstate = wxPyBeginAllowThreads();
24085 delete arg1;
24086
24087 wxPyEndAllowThreads(__tstate);
24088 if (PyErr_Occurred()) SWIG_fail;
24089 }
24090 Py_INCREF(Py_None); resultobj = Py_None;
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24098 PyObject *resultobj;
24099 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24100 wxTimeSpan *arg2 = 0 ;
24101 wxTimeSpan *result;
24102 PyObject * obj0 = 0 ;
24103 PyObject * obj1 = 0 ;
24104 char *kwnames[] = {
24105 (char *) "self",(char *) "diff", NULL
24106 };
24107
24108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24110 if (SWIG_arg_fail(1)) SWIG_fail;
24111 {
24112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24113 if (SWIG_arg_fail(2)) SWIG_fail;
24114 if (arg2 == NULL) {
24115 SWIG_null_ref("wxTimeSpan");
24116 }
24117 if (SWIG_arg_fail(2)) SWIG_fail;
24118 }
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 {
24122 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24123 result = (wxTimeSpan *) &_result_ref;
24124 }
24125
24126 wxPyEndAllowThreads(__tstate);
24127 if (PyErr_Occurred()) SWIG_fail;
24128 }
24129 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24130 return resultobj;
24131 fail:
24132 return NULL;
24133 }
24134
24135
24136 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24137 PyObject *resultobj;
24138 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24139 wxTimeSpan *arg2 = 0 ;
24140 wxTimeSpan *result;
24141 PyObject * obj0 = 0 ;
24142 PyObject * obj1 = 0 ;
24143 char *kwnames[] = {
24144 (char *) "self",(char *) "diff", NULL
24145 };
24146
24147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24149 if (SWIG_arg_fail(1)) SWIG_fail;
24150 {
24151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24152 if (SWIG_arg_fail(2)) SWIG_fail;
24153 if (arg2 == NULL) {
24154 SWIG_null_ref("wxTimeSpan");
24155 }
24156 if (SWIG_arg_fail(2)) SWIG_fail;
24157 }
24158 {
24159 PyThreadState* __tstate = wxPyBeginAllowThreads();
24160 {
24161 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24162 result = (wxTimeSpan *) &_result_ref;
24163 }
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24176 PyObject *resultobj;
24177 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24178 int arg2 ;
24179 wxTimeSpan *result;
24180 PyObject * obj0 = 0 ;
24181 PyObject * obj1 = 0 ;
24182 char *kwnames[] = {
24183 (char *) "self",(char *) "n", NULL
24184 };
24185
24186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24188 if (SWIG_arg_fail(1)) SWIG_fail;
24189 {
24190 arg2 = (int)(SWIG_As_int(obj1));
24191 if (SWIG_arg_fail(2)) SWIG_fail;
24192 }
24193 {
24194 PyThreadState* __tstate = wxPyBeginAllowThreads();
24195 {
24196 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24197 result = (wxTimeSpan *) &_result_ref;
24198 }
24199
24200 wxPyEndAllowThreads(__tstate);
24201 if (PyErr_Occurred()) SWIG_fail;
24202 }
24203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24211 PyObject *resultobj;
24212 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24213 wxTimeSpan *result;
24214 PyObject * obj0 = 0 ;
24215 char *kwnames[] = {
24216 (char *) "self", NULL
24217 };
24218
24219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24221 if (SWIG_arg_fail(1)) SWIG_fail;
24222 {
24223 PyThreadState* __tstate = wxPyBeginAllowThreads();
24224 {
24225 wxTimeSpan &_result_ref = (arg1)->Neg();
24226 result = (wxTimeSpan *) &_result_ref;
24227 }
24228
24229 wxPyEndAllowThreads(__tstate);
24230 if (PyErr_Occurred()) SWIG_fail;
24231 }
24232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj;
24241 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24242 wxTimeSpan result;
24243 PyObject * obj0 = 0 ;
24244 char *kwnames[] = {
24245 (char *) "self", NULL
24246 };
24247
24248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24250 if (SWIG_arg_fail(1)) SWIG_fail;
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 result = ((wxTimeSpan const *)arg1)->Abs();
24254
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 {
24259 wxTimeSpan * resultptr;
24260 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24261 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24262 }
24263 return resultobj;
24264 fail:
24265 return NULL;
24266 }
24267
24268
24269 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24270 PyObject *resultobj;
24271 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24272 wxTimeSpan *arg2 = 0 ;
24273 wxTimeSpan *result;
24274 PyObject * obj0 = 0 ;
24275 PyObject * obj1 = 0 ;
24276 char *kwnames[] = {
24277 (char *) "self",(char *) "diff", NULL
24278 };
24279
24280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24282 if (SWIG_arg_fail(1)) SWIG_fail;
24283 {
24284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24285 if (SWIG_arg_fail(2)) SWIG_fail;
24286 if (arg2 == NULL) {
24287 SWIG_null_ref("wxTimeSpan");
24288 }
24289 if (SWIG_arg_fail(2)) SWIG_fail;
24290 }
24291 {
24292 PyThreadState* __tstate = wxPyBeginAllowThreads();
24293 {
24294 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24295 result = (wxTimeSpan *) &_result_ref;
24296 }
24297
24298 wxPyEndAllowThreads(__tstate);
24299 if (PyErr_Occurred()) SWIG_fail;
24300 }
24301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24309 PyObject *resultobj;
24310 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24311 wxTimeSpan *arg2 = 0 ;
24312 wxTimeSpan *result;
24313 PyObject * obj0 = 0 ;
24314 PyObject * obj1 = 0 ;
24315 char *kwnames[] = {
24316 (char *) "self",(char *) "diff", NULL
24317 };
24318
24319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24321 if (SWIG_arg_fail(1)) SWIG_fail;
24322 {
24323 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24324 if (SWIG_arg_fail(2)) SWIG_fail;
24325 if (arg2 == NULL) {
24326 SWIG_null_ref("wxTimeSpan");
24327 }
24328 if (SWIG_arg_fail(2)) SWIG_fail;
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 {
24333 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24334 result = (wxTimeSpan *) &_result_ref;
24335 }
24336
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24348 PyObject *resultobj;
24349 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24350 int arg2 ;
24351 wxTimeSpan *result;
24352 PyObject * obj0 = 0 ;
24353 PyObject * obj1 = 0 ;
24354 char *kwnames[] = {
24355 (char *) "self",(char *) "n", NULL
24356 };
24357
24358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24360 if (SWIG_arg_fail(1)) SWIG_fail;
24361 {
24362 arg2 = (int)(SWIG_As_int(obj1));
24363 if (SWIG_arg_fail(2)) SWIG_fail;
24364 }
24365 {
24366 PyThreadState* __tstate = wxPyBeginAllowThreads();
24367 {
24368 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24369 result = (wxTimeSpan *) &_result_ref;
24370 }
24371
24372 wxPyEndAllowThreads(__tstate);
24373 if (PyErr_Occurred()) SWIG_fail;
24374 }
24375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24376 return resultobj;
24377 fail:
24378 return NULL;
24379 }
24380
24381
24382 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24383 PyObject *resultobj;
24384 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24385 wxTimeSpan *result;
24386 PyObject * obj0 = 0 ;
24387 char *kwnames[] = {
24388 (char *) "self", NULL
24389 };
24390
24391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24393 if (SWIG_arg_fail(1)) SWIG_fail;
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 {
24397 wxTimeSpan &_result_ref = (arg1)->operator -();
24398 result = (wxTimeSpan *) &_result_ref;
24399 }
24400
24401 wxPyEndAllowThreads(__tstate);
24402 if (PyErr_Occurred()) SWIG_fail;
24403 }
24404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24405 return resultobj;
24406 fail:
24407 return NULL;
24408 }
24409
24410
24411 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24412 PyObject *resultobj;
24413 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24414 wxTimeSpan *arg2 = 0 ;
24415 wxTimeSpan result;
24416 PyObject * obj0 = 0 ;
24417 PyObject * obj1 = 0 ;
24418 char *kwnames[] = {
24419 (char *) "self",(char *) "other", NULL
24420 };
24421
24422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24424 if (SWIG_arg_fail(1)) SWIG_fail;
24425 {
24426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24427 if (SWIG_arg_fail(2)) SWIG_fail;
24428 if (arg2 == NULL) {
24429 SWIG_null_ref("wxTimeSpan");
24430 }
24431 if (SWIG_arg_fail(2)) SWIG_fail;
24432 }
24433 {
24434 PyThreadState* __tstate = wxPyBeginAllowThreads();
24435 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24436
24437 wxPyEndAllowThreads(__tstate);
24438 if (PyErr_Occurred()) SWIG_fail;
24439 }
24440 {
24441 wxTimeSpan * resultptr;
24442 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24443 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24444 }
24445 return resultobj;
24446 fail:
24447 return NULL;
24448 }
24449
24450
24451 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24452 PyObject *resultobj;
24453 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24454 wxTimeSpan *arg2 = 0 ;
24455 wxTimeSpan result;
24456 PyObject * obj0 = 0 ;
24457 PyObject * obj1 = 0 ;
24458 char *kwnames[] = {
24459 (char *) "self",(char *) "other", NULL
24460 };
24461
24462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24464 if (SWIG_arg_fail(1)) SWIG_fail;
24465 {
24466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24467 if (SWIG_arg_fail(2)) SWIG_fail;
24468 if (arg2 == NULL) {
24469 SWIG_null_ref("wxTimeSpan");
24470 }
24471 if (SWIG_arg_fail(2)) SWIG_fail;
24472 }
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24476
24477 wxPyEndAllowThreads(__tstate);
24478 if (PyErr_Occurred()) SWIG_fail;
24479 }
24480 {
24481 wxTimeSpan * resultptr;
24482 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24484 }
24485 return resultobj;
24486 fail:
24487 return NULL;
24488 }
24489
24490
24491 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24492 PyObject *resultobj;
24493 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24494 int arg2 ;
24495 wxTimeSpan result;
24496 PyObject * obj0 = 0 ;
24497 PyObject * obj1 = 0 ;
24498 char *kwnames[] = {
24499 (char *) "self",(char *) "n", NULL
24500 };
24501
24502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24504 if (SWIG_arg_fail(1)) SWIG_fail;
24505 {
24506 arg2 = (int)(SWIG_As_int(obj1));
24507 if (SWIG_arg_fail(2)) SWIG_fail;
24508 }
24509 {
24510 PyThreadState* __tstate = wxPyBeginAllowThreads();
24511 result = wxTimeSpan___mul__(arg1,arg2);
24512
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 {
24517 wxTimeSpan * resultptr;
24518 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24520 }
24521 return resultobj;
24522 fail:
24523 return NULL;
24524 }
24525
24526
24527 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24528 PyObject *resultobj;
24529 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24530 int arg2 ;
24531 wxTimeSpan result;
24532 PyObject * obj0 = 0 ;
24533 PyObject * obj1 = 0 ;
24534 char *kwnames[] = {
24535 (char *) "self",(char *) "n", NULL
24536 };
24537
24538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24540 if (SWIG_arg_fail(1)) SWIG_fail;
24541 {
24542 arg2 = (int)(SWIG_As_int(obj1));
24543 if (SWIG_arg_fail(2)) SWIG_fail;
24544 }
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 result = wxTimeSpan___rmul__(arg1,arg2);
24548
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 {
24553 wxTimeSpan * resultptr;
24554 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24555 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24556 }
24557 return resultobj;
24558 fail:
24559 return NULL;
24560 }
24561
24562
24563 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24564 PyObject *resultobj;
24565 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24566 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24567 bool result;
24568 PyObject * obj0 = 0 ;
24569 PyObject * obj1 = 0 ;
24570 char *kwnames[] = {
24571 (char *) "self",(char *) "other", NULL
24572 };
24573
24574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24576 if (SWIG_arg_fail(1)) SWIG_fail;
24577 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24578 if (SWIG_arg_fail(2)) SWIG_fail;
24579 {
24580 PyThreadState* __tstate = wxPyBeginAllowThreads();
24581 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24582
24583 wxPyEndAllowThreads(__tstate);
24584 if (PyErr_Occurred()) SWIG_fail;
24585 }
24586 {
24587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24588 }
24589 return resultobj;
24590 fail:
24591 return NULL;
24592 }
24593
24594
24595 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24596 PyObject *resultobj;
24597 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24598 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24599 bool result;
24600 PyObject * obj0 = 0 ;
24601 PyObject * obj1 = 0 ;
24602 char *kwnames[] = {
24603 (char *) "self",(char *) "other", NULL
24604 };
24605
24606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24608 if (SWIG_arg_fail(1)) SWIG_fail;
24609 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24610 if (SWIG_arg_fail(2)) SWIG_fail;
24611 {
24612 PyThreadState* __tstate = wxPyBeginAllowThreads();
24613 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24614
24615 wxPyEndAllowThreads(__tstate);
24616 if (PyErr_Occurred()) SWIG_fail;
24617 }
24618 {
24619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24620 }
24621 return resultobj;
24622 fail:
24623 return NULL;
24624 }
24625
24626
24627 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24628 PyObject *resultobj;
24629 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24630 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24631 bool result;
24632 PyObject * obj0 = 0 ;
24633 PyObject * obj1 = 0 ;
24634 char *kwnames[] = {
24635 (char *) "self",(char *) "other", NULL
24636 };
24637
24638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24640 if (SWIG_arg_fail(1)) SWIG_fail;
24641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24642 if (SWIG_arg_fail(2)) SWIG_fail;
24643 {
24644 PyThreadState* __tstate = wxPyBeginAllowThreads();
24645 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24646
24647 wxPyEndAllowThreads(__tstate);
24648 if (PyErr_Occurred()) SWIG_fail;
24649 }
24650 {
24651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24652 }
24653 return resultobj;
24654 fail:
24655 return NULL;
24656 }
24657
24658
24659 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24660 PyObject *resultobj;
24661 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24662 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24663 bool result;
24664 PyObject * obj0 = 0 ;
24665 PyObject * obj1 = 0 ;
24666 char *kwnames[] = {
24667 (char *) "self",(char *) "other", NULL
24668 };
24669
24670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24672 if (SWIG_arg_fail(1)) SWIG_fail;
24673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24674 if (SWIG_arg_fail(2)) SWIG_fail;
24675 {
24676 PyThreadState* __tstate = wxPyBeginAllowThreads();
24677 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24678
24679 wxPyEndAllowThreads(__tstate);
24680 if (PyErr_Occurred()) SWIG_fail;
24681 }
24682 {
24683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24684 }
24685 return resultobj;
24686 fail:
24687 return NULL;
24688 }
24689
24690
24691 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24692 PyObject *resultobj;
24693 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24694 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24695 bool result;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char *kwnames[] = {
24699 (char *) "self",(char *) "other", NULL
24700 };
24701
24702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24704 if (SWIG_arg_fail(1)) SWIG_fail;
24705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24706 if (SWIG_arg_fail(2)) SWIG_fail;
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24710
24711 wxPyEndAllowThreads(__tstate);
24712 if (PyErr_Occurred()) SWIG_fail;
24713 }
24714 {
24715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24716 }
24717 return resultobj;
24718 fail:
24719 return NULL;
24720 }
24721
24722
24723 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24724 PyObject *resultobj;
24725 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24726 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24727 bool result;
24728 PyObject * obj0 = 0 ;
24729 PyObject * obj1 = 0 ;
24730 char *kwnames[] = {
24731 (char *) "self",(char *) "other", NULL
24732 };
24733
24734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24736 if (SWIG_arg_fail(1)) SWIG_fail;
24737 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24738 if (SWIG_arg_fail(2)) SWIG_fail;
24739 {
24740 PyThreadState* __tstate = wxPyBeginAllowThreads();
24741 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24742
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24756 PyObject *resultobj;
24757 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24758 bool result;
24759 PyObject * obj0 = 0 ;
24760 char *kwnames[] = {
24761 (char *) "self", NULL
24762 };
24763
24764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(1)) SWIG_fail;
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24770
24771 wxPyEndAllowThreads(__tstate);
24772 if (PyErr_Occurred()) SWIG_fail;
24773 }
24774 {
24775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24776 }
24777 return resultobj;
24778 fail:
24779 return NULL;
24780 }
24781
24782
24783 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj;
24785 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24786 bool result;
24787 PyObject * obj0 = 0 ;
24788 char *kwnames[] = {
24789 (char *) "self", NULL
24790 };
24791
24792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24794 if (SWIG_arg_fail(1)) SWIG_fail;
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24798
24799 wxPyEndAllowThreads(__tstate);
24800 if (PyErr_Occurred()) SWIG_fail;
24801 }
24802 {
24803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24804 }
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj;
24813 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24814 bool result;
24815 PyObject * obj0 = 0 ;
24816 char *kwnames[] = {
24817 (char *) "self", NULL
24818 };
24819
24820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(1)) SWIG_fail;
24823 {
24824 PyThreadState* __tstate = wxPyBeginAllowThreads();
24825 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24826
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 {
24831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24832 }
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24840 PyObject *resultobj;
24841 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24842 wxTimeSpan *arg2 = 0 ;
24843 bool result;
24844 PyObject * obj0 = 0 ;
24845 PyObject * obj1 = 0 ;
24846 char *kwnames[] = {
24847 (char *) "self",(char *) "ts", NULL
24848 };
24849
24850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24852 if (SWIG_arg_fail(1)) SWIG_fail;
24853 {
24854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24855 if (SWIG_arg_fail(2)) SWIG_fail;
24856 if (arg2 == NULL) {
24857 SWIG_null_ref("wxTimeSpan");
24858 }
24859 if (SWIG_arg_fail(2)) SWIG_fail;
24860 }
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24864
24865 wxPyEndAllowThreads(__tstate);
24866 if (PyErr_Occurred()) SWIG_fail;
24867 }
24868 {
24869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24870 }
24871 return resultobj;
24872 fail:
24873 return NULL;
24874 }
24875
24876
24877 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24878 PyObject *resultobj;
24879 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24880 wxTimeSpan *arg2 = 0 ;
24881 bool result;
24882 PyObject * obj0 = 0 ;
24883 PyObject * obj1 = 0 ;
24884 char *kwnames[] = {
24885 (char *) "self",(char *) "ts", NULL
24886 };
24887
24888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24890 if (SWIG_arg_fail(1)) SWIG_fail;
24891 {
24892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24893 if (SWIG_arg_fail(2)) SWIG_fail;
24894 if (arg2 == NULL) {
24895 SWIG_null_ref("wxTimeSpan");
24896 }
24897 if (SWIG_arg_fail(2)) SWIG_fail;
24898 }
24899 {
24900 PyThreadState* __tstate = wxPyBeginAllowThreads();
24901 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24902
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 {
24907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24908 }
24909 return resultobj;
24910 fail:
24911 return NULL;
24912 }
24913
24914
24915 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24916 PyObject *resultobj;
24917 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24918 wxTimeSpan *arg2 = 0 ;
24919 bool result;
24920 PyObject * obj0 = 0 ;
24921 PyObject * obj1 = 0 ;
24922 char *kwnames[] = {
24923 (char *) "self",(char *) "t", NULL
24924 };
24925
24926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24928 if (SWIG_arg_fail(1)) SWIG_fail;
24929 {
24930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(2)) SWIG_fail;
24932 if (arg2 == NULL) {
24933 SWIG_null_ref("wxTimeSpan");
24934 }
24935 if (SWIG_arg_fail(2)) SWIG_fail;
24936 }
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24940
24941 wxPyEndAllowThreads(__tstate);
24942 if (PyErr_Occurred()) SWIG_fail;
24943 }
24944 {
24945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24946 }
24947 return resultobj;
24948 fail:
24949 return NULL;
24950 }
24951
24952
24953 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24954 PyObject *resultobj;
24955 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24956 int result;
24957 PyObject * obj0 = 0 ;
24958 char *kwnames[] = {
24959 (char *) "self", NULL
24960 };
24961
24962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24964 if (SWIG_arg_fail(1)) SWIG_fail;
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24968
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 {
24973 resultobj = SWIG_From_int((int)(result));
24974 }
24975 return resultobj;
24976 fail:
24977 return NULL;
24978 }
24979
24980
24981 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj;
24983 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24984 int result;
24985 PyObject * obj0 = 0 ;
24986 char *kwnames[] = {
24987 (char *) "self", NULL
24988 };
24989
24990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
24991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24992 if (SWIG_arg_fail(1)) SWIG_fail;
24993 {
24994 PyThreadState* __tstate = wxPyBeginAllowThreads();
24995 result = (int)((wxTimeSpan const *)arg1)->GetDays();
24996
24997 wxPyEndAllowThreads(__tstate);
24998 if (PyErr_Occurred()) SWIG_fail;
24999 }
25000 {
25001 resultobj = SWIG_From_int((int)(result));
25002 }
25003 return resultobj;
25004 fail:
25005 return NULL;
25006 }
25007
25008
25009 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25010 PyObject *resultobj;
25011 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25012 int result;
25013 PyObject * obj0 = 0 ;
25014 char *kwnames[] = {
25015 (char *) "self", NULL
25016 };
25017
25018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25020 if (SWIG_arg_fail(1)) SWIG_fail;
25021 {
25022 PyThreadState* __tstate = wxPyBeginAllowThreads();
25023 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25024
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = SWIG_From_int((int)(result));
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25038 PyObject *resultobj;
25039 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25040 int result;
25041 PyObject * obj0 = 0 ;
25042 char *kwnames[] = {
25043 (char *) "self", NULL
25044 };
25045
25046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25048 if (SWIG_arg_fail(1)) SWIG_fail;
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25052
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 {
25057 resultobj = SWIG_From_int((int)(result));
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25066 PyObject *resultobj;
25067 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25068 wxLongLong result;
25069 PyObject * obj0 = 0 ;
25070 char *kwnames[] = {
25071 (char *) "self", NULL
25072 };
25073
25074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25076 if (SWIG_arg_fail(1)) SWIG_fail;
25077 {
25078 PyThreadState* __tstate = wxPyBeginAllowThreads();
25079 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25080
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 PyObject *hi, *lo, *shifter, *shifted;
25086 hi = PyLong_FromLong( (&result)->GetHi() );
25087 lo = PyLong_FromLong( (&result)->GetLo() );
25088 shifter = PyLong_FromLong(32);
25089 shifted = PyNumber_Lshift(hi, shifter);
25090 resultobj = PyNumber_Or(shifted, lo);
25091 Py_DECREF(hi);
25092 Py_DECREF(lo);
25093 Py_DECREF(shifter);
25094 Py_DECREF(shifted);
25095 }
25096 return resultobj;
25097 fail:
25098 return NULL;
25099 }
25100
25101
25102 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25103 PyObject *resultobj;
25104 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25105 wxLongLong result;
25106 PyObject * obj0 = 0 ;
25107 char *kwnames[] = {
25108 (char *) "self", NULL
25109 };
25110
25111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25113 if (SWIG_arg_fail(1)) SWIG_fail;
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25117
25118 wxPyEndAllowThreads(__tstate);
25119 if (PyErr_Occurred()) SWIG_fail;
25120 }
25121 {
25122 PyObject *hi, *lo, *shifter, *shifted;
25123 hi = PyLong_FromLong( (&result)->GetHi() );
25124 lo = PyLong_FromLong( (&result)->GetLo() );
25125 shifter = PyLong_FromLong(32);
25126 shifted = PyNumber_Lshift(hi, shifter);
25127 resultobj = PyNumber_Or(shifted, lo);
25128 Py_DECREF(hi);
25129 Py_DECREF(lo);
25130 Py_DECREF(shifter);
25131 Py_DECREF(shifted);
25132 }
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25140 PyObject *resultobj;
25141 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25142 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25143 wxString *arg2 = (wxString *) &arg2_defvalue ;
25144 wxString result;
25145 bool temp2 = false ;
25146 PyObject * obj0 = 0 ;
25147 PyObject * obj1 = 0 ;
25148 char *kwnames[] = {
25149 (char *) "self",(char *) "format", NULL
25150 };
25151
25152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25154 if (SWIG_arg_fail(1)) SWIG_fail;
25155 if (obj1) {
25156 {
25157 arg2 = wxString_in_helper(obj1);
25158 if (arg2 == NULL) SWIG_fail;
25159 temp2 = true;
25160 }
25161 }
25162 {
25163 PyThreadState* __tstate = wxPyBeginAllowThreads();
25164 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25165
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 {
25170 #if wxUSE_UNICODE
25171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25172 #else
25173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25174 #endif
25175 }
25176 {
25177 if (temp2)
25178 delete arg2;
25179 }
25180 return resultobj;
25181 fail:
25182 {
25183 if (temp2)
25184 delete arg2;
25185 }
25186 return NULL;
25187 }
25188
25189
25190 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25191 PyObject *obj;
25192 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25193 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25194 Py_INCREF(obj);
25195 return Py_BuildValue((char *)"");
25196 }
25197 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25198 PyObject *resultobj;
25199 int arg1 = (int) 0 ;
25200 int arg2 = (int) 0 ;
25201 int arg3 = (int) 0 ;
25202 int arg4 = (int) 0 ;
25203 wxDateSpan *result;
25204 PyObject * obj0 = 0 ;
25205 PyObject * obj1 = 0 ;
25206 PyObject * obj2 = 0 ;
25207 PyObject * obj3 = 0 ;
25208 char *kwnames[] = {
25209 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25210 };
25211
25212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25213 if (obj0) {
25214 {
25215 arg1 = (int)(SWIG_As_int(obj0));
25216 if (SWIG_arg_fail(1)) SWIG_fail;
25217 }
25218 }
25219 if (obj1) {
25220 {
25221 arg2 = (int)(SWIG_As_int(obj1));
25222 if (SWIG_arg_fail(2)) SWIG_fail;
25223 }
25224 }
25225 if (obj2) {
25226 {
25227 arg3 = (int)(SWIG_As_int(obj2));
25228 if (SWIG_arg_fail(3)) SWIG_fail;
25229 }
25230 }
25231 if (obj3) {
25232 {
25233 arg4 = (int)(SWIG_As_int(obj3));
25234 if (SWIG_arg_fail(4)) SWIG_fail;
25235 }
25236 }
25237 {
25238 PyThreadState* __tstate = wxPyBeginAllowThreads();
25239 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25240
25241 wxPyEndAllowThreads(__tstate);
25242 if (PyErr_Occurred()) SWIG_fail;
25243 }
25244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25245 return resultobj;
25246 fail:
25247 return NULL;
25248 }
25249
25250
25251 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj;
25253 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25254 PyObject * obj0 = 0 ;
25255 char *kwnames[] = {
25256 (char *) "self", NULL
25257 };
25258
25259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25261 if (SWIG_arg_fail(1)) SWIG_fail;
25262 {
25263 PyThreadState* __tstate = wxPyBeginAllowThreads();
25264 delete arg1;
25265
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 Py_INCREF(Py_None); resultobj = Py_None;
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25277 PyObject *resultobj;
25278 int arg1 ;
25279 wxDateSpan result;
25280 PyObject * obj0 = 0 ;
25281 char *kwnames[] = {
25282 (char *) "days", NULL
25283 };
25284
25285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25286 {
25287 arg1 = (int)(SWIG_As_int(obj0));
25288 if (SWIG_arg_fail(1)) SWIG_fail;
25289 }
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = wxDateSpan::Days(arg1);
25293
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 {
25298 wxDateSpan * resultptr;
25299 resultptr = new wxDateSpan((wxDateSpan &)(result));
25300 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25301 }
25302 return resultobj;
25303 fail:
25304 return NULL;
25305 }
25306
25307
25308 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25309 PyObject *resultobj;
25310 wxDateSpan result;
25311 char *kwnames[] = {
25312 NULL
25313 };
25314
25315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25316 {
25317 PyThreadState* __tstate = wxPyBeginAllowThreads();
25318 result = wxDateSpan::Day();
25319
25320 wxPyEndAllowThreads(__tstate);
25321 if (PyErr_Occurred()) SWIG_fail;
25322 }
25323 {
25324 wxDateSpan * resultptr;
25325 resultptr = new wxDateSpan((wxDateSpan &)(result));
25326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25327 }
25328 return resultobj;
25329 fail:
25330 return NULL;
25331 }
25332
25333
25334 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25335 PyObject *resultobj;
25336 int arg1 ;
25337 wxDateSpan result;
25338 PyObject * obj0 = 0 ;
25339 char *kwnames[] = {
25340 (char *) "weeks", NULL
25341 };
25342
25343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25344 {
25345 arg1 = (int)(SWIG_As_int(obj0));
25346 if (SWIG_arg_fail(1)) SWIG_fail;
25347 }
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = wxDateSpan::Weeks(arg1);
25351
25352 wxPyEndAllowThreads(__tstate);
25353 if (PyErr_Occurred()) SWIG_fail;
25354 }
25355 {
25356 wxDateSpan * resultptr;
25357 resultptr = new wxDateSpan((wxDateSpan &)(result));
25358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25359 }
25360 return resultobj;
25361 fail:
25362 return NULL;
25363 }
25364
25365
25366 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25367 PyObject *resultobj;
25368 wxDateSpan result;
25369 char *kwnames[] = {
25370 NULL
25371 };
25372
25373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25374 {
25375 PyThreadState* __tstate = wxPyBeginAllowThreads();
25376 result = wxDateSpan::Week();
25377
25378 wxPyEndAllowThreads(__tstate);
25379 if (PyErr_Occurred()) SWIG_fail;
25380 }
25381 {
25382 wxDateSpan * resultptr;
25383 resultptr = new wxDateSpan((wxDateSpan &)(result));
25384 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25385 }
25386 return resultobj;
25387 fail:
25388 return NULL;
25389 }
25390
25391
25392 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25393 PyObject *resultobj;
25394 int arg1 ;
25395 wxDateSpan result;
25396 PyObject * obj0 = 0 ;
25397 char *kwnames[] = {
25398 (char *) "mon", NULL
25399 };
25400
25401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25402 {
25403 arg1 = (int)(SWIG_As_int(obj0));
25404 if (SWIG_arg_fail(1)) SWIG_fail;
25405 }
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 result = wxDateSpan::Months(arg1);
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 {
25414 wxDateSpan * resultptr;
25415 resultptr = new wxDateSpan((wxDateSpan &)(result));
25416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25417 }
25418 return resultobj;
25419 fail:
25420 return NULL;
25421 }
25422
25423
25424 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25425 PyObject *resultobj;
25426 wxDateSpan result;
25427 char *kwnames[] = {
25428 NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 result = wxDateSpan::Month();
25435
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 {
25440 wxDateSpan * resultptr;
25441 resultptr = new wxDateSpan((wxDateSpan &)(result));
25442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25443 }
25444 return resultobj;
25445 fail:
25446 return NULL;
25447 }
25448
25449
25450 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25451 PyObject *resultobj;
25452 int arg1 ;
25453 wxDateSpan result;
25454 PyObject * obj0 = 0 ;
25455 char *kwnames[] = {
25456 (char *) "years", NULL
25457 };
25458
25459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25460 {
25461 arg1 = (int)(SWIG_As_int(obj0));
25462 if (SWIG_arg_fail(1)) SWIG_fail;
25463 }
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = wxDateSpan::Years(arg1);
25467
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 {
25472 wxDateSpan * resultptr;
25473 resultptr = new wxDateSpan((wxDateSpan &)(result));
25474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25475 }
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25483 PyObject *resultobj;
25484 wxDateSpan result;
25485 char *kwnames[] = {
25486 NULL
25487 };
25488
25489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25490 {
25491 PyThreadState* __tstate = wxPyBeginAllowThreads();
25492 result = wxDateSpan::Year();
25493
25494 wxPyEndAllowThreads(__tstate);
25495 if (PyErr_Occurred()) SWIG_fail;
25496 }
25497 {
25498 wxDateSpan * resultptr;
25499 resultptr = new wxDateSpan((wxDateSpan &)(result));
25500 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25501 }
25502 return resultobj;
25503 fail:
25504 return NULL;
25505 }
25506
25507
25508 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25509 PyObject *resultobj;
25510 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25511 int arg2 ;
25512 wxDateSpan *result;
25513 PyObject * obj0 = 0 ;
25514 PyObject * obj1 = 0 ;
25515 char *kwnames[] = {
25516 (char *) "self",(char *) "n", NULL
25517 };
25518
25519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25521 if (SWIG_arg_fail(1)) SWIG_fail;
25522 {
25523 arg2 = (int)(SWIG_As_int(obj1));
25524 if (SWIG_arg_fail(2)) SWIG_fail;
25525 }
25526 {
25527 PyThreadState* __tstate = wxPyBeginAllowThreads();
25528 {
25529 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25530 result = (wxDateSpan *) &_result_ref;
25531 }
25532
25533 wxPyEndAllowThreads(__tstate);
25534 if (PyErr_Occurred()) SWIG_fail;
25535 }
25536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25537 return resultobj;
25538 fail:
25539 return NULL;
25540 }
25541
25542
25543 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25544 PyObject *resultobj;
25545 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25546 int arg2 ;
25547 wxDateSpan *result;
25548 PyObject * obj0 = 0 ;
25549 PyObject * obj1 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self",(char *) "n", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 arg2 = (int)(SWIG_As_int(obj1));
25559 if (SWIG_arg_fail(2)) SWIG_fail;
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 {
25564 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25565 result = (wxDateSpan *) &_result_ref;
25566 }
25567
25568 wxPyEndAllowThreads(__tstate);
25569 if (PyErr_Occurred()) SWIG_fail;
25570 }
25571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25572 return resultobj;
25573 fail:
25574 return NULL;
25575 }
25576
25577
25578 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25579 PyObject *resultobj;
25580 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25581 int arg2 ;
25582 wxDateSpan *result;
25583 PyObject * obj0 = 0 ;
25584 PyObject * obj1 = 0 ;
25585 char *kwnames[] = {
25586 (char *) "self",(char *) "n", NULL
25587 };
25588
25589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25591 if (SWIG_arg_fail(1)) SWIG_fail;
25592 {
25593 arg2 = (int)(SWIG_As_int(obj1));
25594 if (SWIG_arg_fail(2)) SWIG_fail;
25595 }
25596 {
25597 PyThreadState* __tstate = wxPyBeginAllowThreads();
25598 {
25599 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25600 result = (wxDateSpan *) &_result_ref;
25601 }
25602
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj;
25615 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25616 int arg2 ;
25617 wxDateSpan *result;
25618 PyObject * obj0 = 0 ;
25619 PyObject * obj1 = 0 ;
25620 char *kwnames[] = {
25621 (char *) "self",(char *) "n", NULL
25622 };
25623
25624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25626 if (SWIG_arg_fail(1)) SWIG_fail;
25627 {
25628 arg2 = (int)(SWIG_As_int(obj1));
25629 if (SWIG_arg_fail(2)) SWIG_fail;
25630 }
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 {
25634 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25635 result = (wxDateSpan *) &_result_ref;
25636 }
25637
25638 wxPyEndAllowThreads(__tstate);
25639 if (PyErr_Occurred()) SWIG_fail;
25640 }
25641 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25649 PyObject *resultobj;
25650 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25651 int result;
25652 PyObject * obj0 = 0 ;
25653 char *kwnames[] = {
25654 (char *) "self", NULL
25655 };
25656
25657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25659 if (SWIG_arg_fail(1)) SWIG_fail;
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (int)((wxDateSpan const *)arg1)->GetYears();
25663
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 {
25668 resultobj = SWIG_From_int((int)(result));
25669 }
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25677 PyObject *resultobj;
25678 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25679 int result;
25680 PyObject * obj0 = 0 ;
25681 char *kwnames[] = {
25682 (char *) "self", NULL
25683 };
25684
25685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25687 if (SWIG_arg_fail(1)) SWIG_fail;
25688 {
25689 PyThreadState* __tstate = wxPyBeginAllowThreads();
25690 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25691
25692 wxPyEndAllowThreads(__tstate);
25693 if (PyErr_Occurred()) SWIG_fail;
25694 }
25695 {
25696 resultobj = SWIG_From_int((int)(result));
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj;
25706 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25707 int result;
25708 PyObject * obj0 = 0 ;
25709 char *kwnames[] = {
25710 (char *) "self", NULL
25711 };
25712
25713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25715 if (SWIG_arg_fail(1)) SWIG_fail;
25716 {
25717 PyThreadState* __tstate = wxPyBeginAllowThreads();
25718 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25719
25720 wxPyEndAllowThreads(__tstate);
25721 if (PyErr_Occurred()) SWIG_fail;
25722 }
25723 {
25724 resultobj = SWIG_From_int((int)(result));
25725 }
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj;
25734 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25735 int result;
25736 PyObject * obj0 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self", NULL
25739 };
25740
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 {
25745 PyThreadState* __tstate = wxPyBeginAllowThreads();
25746 result = (int)((wxDateSpan const *)arg1)->GetDays();
25747
25748 wxPyEndAllowThreads(__tstate);
25749 if (PyErr_Occurred()) SWIG_fail;
25750 }
25751 {
25752 resultobj = SWIG_From_int((int)(result));
25753 }
25754 return resultobj;
25755 fail:
25756 return NULL;
25757 }
25758
25759
25760 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25761 PyObject *resultobj;
25762 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25763 int result;
25764 PyObject * obj0 = 0 ;
25765 char *kwnames[] = {
25766 (char *) "self", NULL
25767 };
25768
25769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25771 if (SWIG_arg_fail(1)) SWIG_fail;
25772 {
25773 PyThreadState* __tstate = wxPyBeginAllowThreads();
25774 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25775
25776 wxPyEndAllowThreads(__tstate);
25777 if (PyErr_Occurred()) SWIG_fail;
25778 }
25779 {
25780 resultobj = SWIG_From_int((int)(result));
25781 }
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25789 PyObject *resultobj;
25790 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25791 wxDateSpan *arg2 = 0 ;
25792 wxDateSpan *result;
25793 PyObject * obj0 = 0 ;
25794 PyObject * obj1 = 0 ;
25795 char *kwnames[] = {
25796 (char *) "self",(char *) "other", NULL
25797 };
25798
25799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25801 if (SWIG_arg_fail(1)) SWIG_fail;
25802 {
25803 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25804 if (SWIG_arg_fail(2)) SWIG_fail;
25805 if (arg2 == NULL) {
25806 SWIG_null_ref("wxDateSpan");
25807 }
25808 if (SWIG_arg_fail(2)) SWIG_fail;
25809 }
25810 {
25811 PyThreadState* __tstate = wxPyBeginAllowThreads();
25812 {
25813 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25814 result = (wxDateSpan *) &_result_ref;
25815 }
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj;
25829 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25830 wxDateSpan *arg2 = 0 ;
25831 wxDateSpan *result;
25832 PyObject * obj0 = 0 ;
25833 PyObject * obj1 = 0 ;
25834 char *kwnames[] = {
25835 (char *) "self",(char *) "other", NULL
25836 };
25837
25838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25840 if (SWIG_arg_fail(1)) SWIG_fail;
25841 {
25842 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25843 if (SWIG_arg_fail(2)) SWIG_fail;
25844 if (arg2 == NULL) {
25845 SWIG_null_ref("wxDateSpan");
25846 }
25847 if (SWIG_arg_fail(2)) SWIG_fail;
25848 }
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 {
25852 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25853 result = (wxDateSpan *) &_result_ref;
25854 }
25855
25856 wxPyEndAllowThreads(__tstate);
25857 if (PyErr_Occurred()) SWIG_fail;
25858 }
25859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25860 return resultobj;
25861 fail:
25862 return NULL;
25863 }
25864
25865
25866 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25867 PyObject *resultobj;
25868 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25869 wxDateSpan *result;
25870 PyObject * obj0 = 0 ;
25871 char *kwnames[] = {
25872 (char *) "self", NULL
25873 };
25874
25875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25877 if (SWIG_arg_fail(1)) SWIG_fail;
25878 {
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 {
25881 wxDateSpan &_result_ref = (arg1)->Neg();
25882 result = (wxDateSpan *) &_result_ref;
25883 }
25884
25885 wxPyEndAllowThreads(__tstate);
25886 if (PyErr_Occurred()) SWIG_fail;
25887 }
25888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj;
25897 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25898 int arg2 ;
25899 wxDateSpan *result;
25900 PyObject * obj0 = 0 ;
25901 PyObject * obj1 = 0 ;
25902 char *kwnames[] = {
25903 (char *) "self",(char *) "factor", NULL
25904 };
25905
25906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25908 if (SWIG_arg_fail(1)) SWIG_fail;
25909 {
25910 arg2 = (int)(SWIG_As_int(obj1));
25911 if (SWIG_arg_fail(2)) SWIG_fail;
25912 }
25913 {
25914 PyThreadState* __tstate = wxPyBeginAllowThreads();
25915 {
25916 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25917 result = (wxDateSpan *) &_result_ref;
25918 }
25919
25920 wxPyEndAllowThreads(__tstate);
25921 if (PyErr_Occurred()) SWIG_fail;
25922 }
25923 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25924 return resultobj;
25925 fail:
25926 return NULL;
25927 }
25928
25929
25930 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25931 PyObject *resultobj;
25932 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25933 wxDateSpan *arg2 = 0 ;
25934 wxDateSpan *result;
25935 PyObject * obj0 = 0 ;
25936 PyObject * obj1 = 0 ;
25937 char *kwnames[] = {
25938 (char *) "self",(char *) "other", NULL
25939 };
25940
25941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25943 if (SWIG_arg_fail(1)) SWIG_fail;
25944 {
25945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25946 if (SWIG_arg_fail(2)) SWIG_fail;
25947 if (arg2 == NULL) {
25948 SWIG_null_ref("wxDateSpan");
25949 }
25950 if (SWIG_arg_fail(2)) SWIG_fail;
25951 }
25952 {
25953 PyThreadState* __tstate = wxPyBeginAllowThreads();
25954 {
25955 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25956 result = (wxDateSpan *) &_result_ref;
25957 }
25958
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25970 PyObject *resultobj;
25971 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25972 wxDateSpan *arg2 = 0 ;
25973 wxDateSpan *result;
25974 PyObject * obj0 = 0 ;
25975 PyObject * obj1 = 0 ;
25976 char *kwnames[] = {
25977 (char *) "self",(char *) "other", NULL
25978 };
25979
25980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25982 if (SWIG_arg_fail(1)) SWIG_fail;
25983 {
25984 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25985 if (SWIG_arg_fail(2)) SWIG_fail;
25986 if (arg2 == NULL) {
25987 SWIG_null_ref("wxDateSpan");
25988 }
25989 if (SWIG_arg_fail(2)) SWIG_fail;
25990 }
25991 {
25992 PyThreadState* __tstate = wxPyBeginAllowThreads();
25993 {
25994 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
25995 result = (wxDateSpan *) &_result_ref;
25996 }
25997
25998 wxPyEndAllowThreads(__tstate);
25999 if (PyErr_Occurred()) SWIG_fail;
26000 }
26001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26002 return resultobj;
26003 fail:
26004 return NULL;
26005 }
26006
26007
26008 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj;
26010 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26011 wxDateSpan *result;
26012 PyObject * obj0 = 0 ;
26013 char *kwnames[] = {
26014 (char *) "self", NULL
26015 };
26016
26017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26019 if (SWIG_arg_fail(1)) SWIG_fail;
26020 {
26021 PyThreadState* __tstate = wxPyBeginAllowThreads();
26022 {
26023 wxDateSpan &_result_ref = (arg1)->operator -();
26024 result = (wxDateSpan *) &_result_ref;
26025 }
26026
26027 wxPyEndAllowThreads(__tstate);
26028 if (PyErr_Occurred()) SWIG_fail;
26029 }
26030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26031 return resultobj;
26032 fail:
26033 return NULL;
26034 }
26035
26036
26037 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26038 PyObject *resultobj;
26039 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26040 int arg2 ;
26041 wxDateSpan *result;
26042 PyObject * obj0 = 0 ;
26043 PyObject * obj1 = 0 ;
26044 char *kwnames[] = {
26045 (char *) "self",(char *) "factor", NULL
26046 };
26047
26048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26050 if (SWIG_arg_fail(1)) SWIG_fail;
26051 {
26052 arg2 = (int)(SWIG_As_int(obj1));
26053 if (SWIG_arg_fail(2)) SWIG_fail;
26054 }
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 {
26058 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26059 result = (wxDateSpan *) &_result_ref;
26060 }
26061
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26073 PyObject *resultobj;
26074 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26075 wxDateSpan *arg2 = 0 ;
26076 wxDateSpan result;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self",(char *) "other", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26088 if (SWIG_arg_fail(2)) SWIG_fail;
26089 if (arg2 == NULL) {
26090 SWIG_null_ref("wxDateSpan");
26091 }
26092 if (SWIG_arg_fail(2)) SWIG_fail;
26093 }
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26097
26098 wxPyEndAllowThreads(__tstate);
26099 if (PyErr_Occurred()) SWIG_fail;
26100 }
26101 {
26102 wxDateSpan * resultptr;
26103 resultptr = new wxDateSpan((wxDateSpan &)(result));
26104 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26105 }
26106 return resultobj;
26107 fail:
26108 return NULL;
26109 }
26110
26111
26112 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26113 PyObject *resultobj;
26114 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26115 wxDateSpan *arg2 = 0 ;
26116 wxDateSpan result;
26117 PyObject * obj0 = 0 ;
26118 PyObject * obj1 = 0 ;
26119 char *kwnames[] = {
26120 (char *) "self",(char *) "other", NULL
26121 };
26122
26123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26125 if (SWIG_arg_fail(1)) SWIG_fail;
26126 {
26127 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26128 if (SWIG_arg_fail(2)) SWIG_fail;
26129 if (arg2 == NULL) {
26130 SWIG_null_ref("wxDateSpan");
26131 }
26132 if (SWIG_arg_fail(2)) SWIG_fail;
26133 }
26134 {
26135 PyThreadState* __tstate = wxPyBeginAllowThreads();
26136 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26137
26138 wxPyEndAllowThreads(__tstate);
26139 if (PyErr_Occurred()) SWIG_fail;
26140 }
26141 {
26142 wxDateSpan * resultptr;
26143 resultptr = new wxDateSpan((wxDateSpan &)(result));
26144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26145 }
26146 return resultobj;
26147 fail:
26148 return NULL;
26149 }
26150
26151
26152 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26153 PyObject *resultobj;
26154 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26155 int arg2 ;
26156 wxDateSpan result;
26157 PyObject * obj0 = 0 ;
26158 PyObject * obj1 = 0 ;
26159 char *kwnames[] = {
26160 (char *) "self",(char *) "n", NULL
26161 };
26162
26163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26165 if (SWIG_arg_fail(1)) SWIG_fail;
26166 {
26167 arg2 = (int)(SWIG_As_int(obj1));
26168 if (SWIG_arg_fail(2)) SWIG_fail;
26169 }
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = wxDateSpan___mul__(arg1,arg2);
26173
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 {
26178 wxDateSpan * resultptr;
26179 resultptr = new wxDateSpan((wxDateSpan &)(result));
26180 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26181 }
26182 return resultobj;
26183 fail:
26184 return NULL;
26185 }
26186
26187
26188 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26189 PyObject *resultobj;
26190 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26191 int arg2 ;
26192 wxDateSpan result;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195 char *kwnames[] = {
26196 (char *) "self",(char *) "n", NULL
26197 };
26198
26199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26201 if (SWIG_arg_fail(1)) SWIG_fail;
26202 {
26203 arg2 = (int)(SWIG_As_int(obj1));
26204 if (SWIG_arg_fail(2)) SWIG_fail;
26205 }
26206 {
26207 PyThreadState* __tstate = wxPyBeginAllowThreads();
26208 result = wxDateSpan___rmul__(arg1,arg2);
26209
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 {
26214 wxDateSpan * resultptr;
26215 resultptr = new wxDateSpan((wxDateSpan &)(result));
26216 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26217 }
26218 return resultobj;
26219 fail:
26220 return NULL;
26221 }
26222
26223
26224 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26225 PyObject *resultobj;
26226 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26227 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26228 bool result;
26229 PyObject * obj0 = 0 ;
26230 PyObject * obj1 = 0 ;
26231 char *kwnames[] = {
26232 (char *) "self",(char *) "other", NULL
26233 };
26234
26235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26237 if (SWIG_arg_fail(1)) SWIG_fail;
26238 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26239 if (SWIG_arg_fail(2)) SWIG_fail;
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26243
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 {
26248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26257 PyObject *resultobj;
26258 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26259 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26260 bool result;
26261 PyObject * obj0 = 0 ;
26262 PyObject * obj1 = 0 ;
26263 char *kwnames[] = {
26264 (char *) "self",(char *) "other", NULL
26265 };
26266
26267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26269 if (SWIG_arg_fail(1)) SWIG_fail;
26270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26271 if (SWIG_arg_fail(2)) SWIG_fail;
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26275
26276 wxPyEndAllowThreads(__tstate);
26277 if (PyErr_Occurred()) SWIG_fail;
26278 }
26279 {
26280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26281 }
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26289 PyObject *obj;
26290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26291 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26292 Py_INCREF(obj);
26293 return Py_BuildValue((char *)"");
26294 }
26295 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26296 PyObject *resultobj;
26297 long result;
26298 char *kwnames[] = {
26299 NULL
26300 };
26301
26302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26303 {
26304 PyThreadState* __tstate = wxPyBeginAllowThreads();
26305 result = (long)wxGetLocalTime();
26306
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 {
26311 resultobj = SWIG_From_long((long)(result));
26312 }
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj;
26321 long result;
26322 char *kwnames[] = {
26323 NULL
26324 };
26325
26326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 result = (long)wxGetUTCTime();
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 {
26335 resultobj = SWIG_From_long((long)(result));
26336 }
26337 return resultobj;
26338 fail:
26339 return NULL;
26340 }
26341
26342
26343 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26344 PyObject *resultobj;
26345 long result;
26346 char *kwnames[] = {
26347 NULL
26348 };
26349
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26351 {
26352 PyThreadState* __tstate = wxPyBeginAllowThreads();
26353 result = (long)wxGetCurrentTime();
26354
26355 wxPyEndAllowThreads(__tstate);
26356 if (PyErr_Occurred()) SWIG_fail;
26357 }
26358 {
26359 resultobj = SWIG_From_long((long)(result));
26360 }
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj;
26369 wxLongLong result;
26370 char *kwnames[] = {
26371 NULL
26372 };
26373
26374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26375 {
26376 PyThreadState* __tstate = wxPyBeginAllowThreads();
26377 result = wxGetLocalTimeMillis();
26378
26379 wxPyEndAllowThreads(__tstate);
26380 if (PyErr_Occurred()) SWIG_fail;
26381 }
26382 {
26383 PyObject *hi, *lo, *shifter, *shifted;
26384 hi = PyLong_FromLong( (&result)->GetHi() );
26385 lo = PyLong_FromLong( (&result)->GetLo() );
26386 shifter = PyLong_FromLong(32);
26387 shifted = PyNumber_Lshift(hi, shifter);
26388 resultobj = PyNumber_Or(shifted, lo);
26389 Py_DECREF(hi);
26390 Py_DECREF(lo);
26391 Py_DECREF(shifter);
26392 Py_DECREF(shifted);
26393 }
26394 return resultobj;
26395 fail:
26396 return NULL;
26397 }
26398
26399
26400 static int _wrap_DefaultDateTime_set(PyObject *) {
26401 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26402 return 1;
26403 }
26404
26405
26406 static PyObject *_wrap_DefaultDateTime_get(void) {
26407 PyObject *pyobj;
26408
26409 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26410 return pyobj;
26411 }
26412
26413
26414 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj;
26416 wxDataFormatId arg1 ;
26417 wxDataFormat *result;
26418 PyObject * obj0 = 0 ;
26419 char *kwnames[] = {
26420 (char *) "type", NULL
26421 };
26422
26423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26424 {
26425 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26426 if (SWIG_arg_fail(1)) SWIG_fail;
26427 }
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26431
26432 wxPyEndAllowThreads(__tstate);
26433 if (PyErr_Occurred()) SWIG_fail;
26434 }
26435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26436 return resultobj;
26437 fail:
26438 return NULL;
26439 }
26440
26441
26442 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj;
26444 wxString *arg1 = 0 ;
26445 wxDataFormat *result;
26446 bool temp1 = false ;
26447 PyObject * obj0 = 0 ;
26448 char *kwnames[] = {
26449 (char *) "format", NULL
26450 };
26451
26452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26453 {
26454 arg1 = wxString_in_helper(obj0);
26455 if (arg1 == NULL) SWIG_fail;
26456 temp1 = true;
26457 }
26458 {
26459 PyThreadState* __tstate = wxPyBeginAllowThreads();
26460 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26461
26462 wxPyEndAllowThreads(__tstate);
26463 if (PyErr_Occurred()) SWIG_fail;
26464 }
26465 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26466 {
26467 if (temp1)
26468 delete arg1;
26469 }
26470 return resultobj;
26471 fail:
26472 {
26473 if (temp1)
26474 delete arg1;
26475 }
26476 return NULL;
26477 }
26478
26479
26480 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26481 PyObject *resultobj;
26482 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26483 PyObject * obj0 = 0 ;
26484 char *kwnames[] = {
26485 (char *) "self", NULL
26486 };
26487
26488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26490 if (SWIG_arg_fail(1)) SWIG_fail;
26491 {
26492 PyThreadState* __tstate = wxPyBeginAllowThreads();
26493 delete arg1;
26494
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 Py_INCREF(Py_None); resultobj = Py_None;
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26506 PyObject *resultobj;
26507 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26508 wxDataFormatId arg2 ;
26509 bool result;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512
26513 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 {
26517 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26518 if (SWIG_arg_fail(2)) SWIG_fail;
26519 }
26520 {
26521 PyThreadState* __tstate = wxPyBeginAllowThreads();
26522 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26523
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 {
26528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26529 }
26530 return resultobj;
26531 fail:
26532 return NULL;
26533 }
26534
26535
26536 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26537 PyObject *resultobj;
26538 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26539 wxDataFormatId arg2 ;
26540 bool result;
26541 PyObject * obj0 = 0 ;
26542 PyObject * obj1 = 0 ;
26543
26544 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26546 if (SWIG_arg_fail(1)) SWIG_fail;
26547 {
26548 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26549 if (SWIG_arg_fail(2)) SWIG_fail;
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26554
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 {
26559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26560 }
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26568 PyObject *resultobj;
26569 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26570 wxDataFormat *arg2 = 0 ;
26571 bool result;
26572 PyObject * obj0 = 0 ;
26573 PyObject * obj1 = 0 ;
26574
26575 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26577 if (SWIG_arg_fail(1)) SWIG_fail;
26578 {
26579 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26580 if (SWIG_arg_fail(2)) SWIG_fail;
26581 if (arg2 == NULL) {
26582 SWIG_null_ref("wxDataFormat");
26583 }
26584 if (SWIG_arg_fail(2)) SWIG_fail;
26585 }
26586 {
26587 PyThreadState* __tstate = wxPyBeginAllowThreads();
26588 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26589
26590 wxPyEndAllowThreads(__tstate);
26591 if (PyErr_Occurred()) SWIG_fail;
26592 }
26593 {
26594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26595 }
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26603 int argc;
26604 PyObject *argv[3];
26605 int ii;
26606
26607 argc = PyObject_Length(args);
26608 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26609 argv[ii] = PyTuple_GetItem(args,ii);
26610 }
26611 if (argc == 2) {
26612 int _v;
26613 {
26614 void *ptr;
26615 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26616 _v = 0;
26617 PyErr_Clear();
26618 } else {
26619 _v = 1;
26620 }
26621 }
26622 if (_v) {
26623 {
26624 void *ptr = 0;
26625 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26626 _v = 0;
26627 PyErr_Clear();
26628 } else {
26629 _v = (ptr != 0);
26630 }
26631 }
26632 if (_v) {
26633 return _wrap_DataFormat___eq____SWIG_1(self,args);
26634 }
26635 }
26636 }
26637 if (argc == 2) {
26638 int _v;
26639 {
26640 void *ptr;
26641 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26642 _v = 0;
26643 PyErr_Clear();
26644 } else {
26645 _v = 1;
26646 }
26647 }
26648 if (_v) {
26649 _v = SWIG_Check_int(argv[1]);
26650 if (_v) {
26651 return _wrap_DataFormat___eq____SWIG_0(self,args);
26652 }
26653 }
26654 }
26655
26656 Py_INCREF(Py_NotImplemented);
26657 return Py_NotImplemented;
26658 }
26659
26660
26661 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26662 PyObject *resultobj;
26663 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26664 wxDataFormat *arg2 = 0 ;
26665 bool result;
26666 PyObject * obj0 = 0 ;
26667 PyObject * obj1 = 0 ;
26668
26669 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26671 if (SWIG_arg_fail(1)) SWIG_fail;
26672 {
26673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26674 if (SWIG_arg_fail(2)) SWIG_fail;
26675 if (arg2 == NULL) {
26676 SWIG_null_ref("wxDataFormat");
26677 }
26678 if (SWIG_arg_fail(2)) SWIG_fail;
26679 }
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26683
26684 wxPyEndAllowThreads(__tstate);
26685 if (PyErr_Occurred()) SWIG_fail;
26686 }
26687 {
26688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26689 }
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26697 int argc;
26698 PyObject *argv[3];
26699 int ii;
26700
26701 argc = PyObject_Length(args);
26702 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26703 argv[ii] = PyTuple_GetItem(args,ii);
26704 }
26705 if (argc == 2) {
26706 int _v;
26707 {
26708 void *ptr;
26709 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26710 _v = 0;
26711 PyErr_Clear();
26712 } else {
26713 _v = 1;
26714 }
26715 }
26716 if (_v) {
26717 {
26718 void *ptr = 0;
26719 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26720 _v = 0;
26721 PyErr_Clear();
26722 } else {
26723 _v = (ptr != 0);
26724 }
26725 }
26726 if (_v) {
26727 return _wrap_DataFormat___ne____SWIG_1(self,args);
26728 }
26729 }
26730 }
26731 if (argc == 2) {
26732 int _v;
26733 {
26734 void *ptr;
26735 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26736 _v = 0;
26737 PyErr_Clear();
26738 } else {
26739 _v = 1;
26740 }
26741 }
26742 if (_v) {
26743 _v = SWIG_Check_int(argv[1]);
26744 if (_v) {
26745 return _wrap_DataFormat___ne____SWIG_0(self,args);
26746 }
26747 }
26748 }
26749
26750 Py_INCREF(Py_NotImplemented);
26751 return Py_NotImplemented;
26752 }
26753
26754
26755 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26756 PyObject *resultobj;
26757 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26758 wxDataFormatId arg2 ;
26759 PyObject * obj0 = 0 ;
26760 PyObject * obj1 = 0 ;
26761 char *kwnames[] = {
26762 (char *) "self",(char *) "format", NULL
26763 };
26764
26765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26767 if (SWIG_arg_fail(1)) SWIG_fail;
26768 {
26769 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26770 if (SWIG_arg_fail(2)) SWIG_fail;
26771 }
26772 {
26773 PyThreadState* __tstate = wxPyBeginAllowThreads();
26774 (arg1)->SetType((wxDataFormatId )arg2);
26775
26776 wxPyEndAllowThreads(__tstate);
26777 if (PyErr_Occurred()) SWIG_fail;
26778 }
26779 Py_INCREF(Py_None); resultobj = Py_None;
26780 return resultobj;
26781 fail:
26782 return NULL;
26783 }
26784
26785
26786 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26787 PyObject *resultobj;
26788 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26789 wxDataFormatId result;
26790 PyObject * obj0 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26801
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_From_int((result));
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj;
26814 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26815 wxString result;
26816 PyObject * obj0 = 0 ;
26817 char *kwnames[] = {
26818 (char *) "self", NULL
26819 };
26820
26821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26823 if (SWIG_arg_fail(1)) SWIG_fail;
26824 {
26825 PyThreadState* __tstate = wxPyBeginAllowThreads();
26826 result = ((wxDataFormat const *)arg1)->GetId();
26827
26828 wxPyEndAllowThreads(__tstate);
26829 if (PyErr_Occurred()) SWIG_fail;
26830 }
26831 {
26832 #if wxUSE_UNICODE
26833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26834 #else
26835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26836 #endif
26837 }
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj;
26846 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26847 wxString *arg2 = 0 ;
26848 bool temp2 = false ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 char *kwnames[] = {
26852 (char *) "self",(char *) "format", NULL
26853 };
26854
26855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26857 if (SWIG_arg_fail(1)) SWIG_fail;
26858 {
26859 arg2 = wxString_in_helper(obj1);
26860 if (arg2 == NULL) SWIG_fail;
26861 temp2 = true;
26862 }
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 (arg1)->SetId((wxString const &)*arg2);
26866
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 Py_INCREF(Py_None); resultobj = Py_None;
26871 {
26872 if (temp2)
26873 delete arg2;
26874 }
26875 return resultobj;
26876 fail:
26877 {
26878 if (temp2)
26879 delete arg2;
26880 }
26881 return NULL;
26882 }
26883
26884
26885 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26886 PyObject *obj;
26887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26888 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26889 Py_INCREF(obj);
26890 return Py_BuildValue((char *)"");
26891 }
26892 static int _wrap_FormatInvalid_set(PyObject *) {
26893 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26894 return 1;
26895 }
26896
26897
26898 static PyObject *_wrap_FormatInvalid_get(void) {
26899 PyObject *pyobj;
26900
26901 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26902 return pyobj;
26903 }
26904
26905
26906 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj;
26908 wxDataObject *arg1 = (wxDataObject *) 0 ;
26909 PyObject * obj0 = 0 ;
26910 char *kwnames[] = {
26911 (char *) "self", NULL
26912 };
26913
26914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26916 if (SWIG_arg_fail(1)) SWIG_fail;
26917 {
26918 PyThreadState* __tstate = wxPyBeginAllowThreads();
26919 delete arg1;
26920
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 Py_INCREF(Py_None); resultobj = Py_None;
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26932 PyObject *resultobj;
26933 wxDataObject *arg1 = (wxDataObject *) 0 ;
26934 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26935 SwigValueWrapper<wxDataFormat > result;
26936 PyObject * obj0 = 0 ;
26937 PyObject * obj1 = 0 ;
26938 char *kwnames[] = {
26939 (char *) "self",(char *) "dir", NULL
26940 };
26941
26942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(1)) SWIG_fail;
26945 if (obj1) {
26946 {
26947 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26948 if (SWIG_arg_fail(2)) SWIG_fail;
26949 }
26950 }
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26954
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 {
26959 wxDataFormat * resultptr;
26960 resultptr = new wxDataFormat((wxDataFormat &)(result));
26961 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26962 }
26963 return resultobj;
26964 fail:
26965 return NULL;
26966 }
26967
26968
26969 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26970 PyObject *resultobj;
26971 wxDataObject *arg1 = (wxDataObject *) 0 ;
26972 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26973 size_t result;
26974 PyObject * obj0 = 0 ;
26975 PyObject * obj1 = 0 ;
26976 char *kwnames[] = {
26977 (char *) "self",(char *) "dir", NULL
26978 };
26979
26980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26982 if (SWIG_arg_fail(1)) SWIG_fail;
26983 if (obj1) {
26984 {
26985 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26986 if (SWIG_arg_fail(2)) SWIG_fail;
26987 }
26988 }
26989 {
26990 PyThreadState* __tstate = wxPyBeginAllowThreads();
26991 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
26992
26993 wxPyEndAllowThreads(__tstate);
26994 if (PyErr_Occurred()) SWIG_fail;
26995 }
26996 {
26997 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
26998 }
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj;
27007 wxDataObject *arg1 = (wxDataObject *) 0 ;
27008 wxDataFormat *arg2 = 0 ;
27009 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27010 bool result;
27011 PyObject * obj0 = 0 ;
27012 PyObject * obj1 = 0 ;
27013 PyObject * obj2 = 0 ;
27014 char *kwnames[] = {
27015 (char *) "self",(char *) "format",(char *) "dir", NULL
27016 };
27017
27018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27020 if (SWIG_arg_fail(1)) SWIG_fail;
27021 {
27022 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27023 if (SWIG_arg_fail(2)) SWIG_fail;
27024 if (arg2 == NULL) {
27025 SWIG_null_ref("wxDataFormat");
27026 }
27027 if (SWIG_arg_fail(2)) SWIG_fail;
27028 }
27029 if (obj2) {
27030 {
27031 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27032 if (SWIG_arg_fail(3)) SWIG_fail;
27033 }
27034 }
27035 {
27036 PyThreadState* __tstate = wxPyBeginAllowThreads();
27037 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27038
27039 wxPyEndAllowThreads(__tstate);
27040 if (PyErr_Occurred()) SWIG_fail;
27041 }
27042 {
27043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27044 }
27045 return resultobj;
27046 fail:
27047 return NULL;
27048 }
27049
27050
27051 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27052 PyObject *resultobj;
27053 wxDataObject *arg1 = (wxDataObject *) 0 ;
27054 wxDataFormat *arg2 = 0 ;
27055 size_t result;
27056 PyObject * obj0 = 0 ;
27057 PyObject * obj1 = 0 ;
27058 char *kwnames[] = {
27059 (char *) "self",(char *) "format", NULL
27060 };
27061
27062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(1)) SWIG_fail;
27065 {
27066 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27067 if (SWIG_arg_fail(2)) SWIG_fail;
27068 if (arg2 == NULL) {
27069 SWIG_null_ref("wxDataFormat");
27070 }
27071 if (SWIG_arg_fail(2)) SWIG_fail;
27072 }
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27076
27077 wxPyEndAllowThreads(__tstate);
27078 if (PyErr_Occurred()) SWIG_fail;
27079 }
27080 {
27081 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27082 }
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27090 PyObject *resultobj;
27091 wxDataObject *arg1 = (wxDataObject *) 0 ;
27092 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27093 PyObject *result;
27094 PyObject * obj0 = 0 ;
27095 PyObject * obj1 = 0 ;
27096 char *kwnames[] = {
27097 (char *) "self",(char *) "dir", NULL
27098 };
27099
27100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27102 if (SWIG_arg_fail(1)) SWIG_fail;
27103 if (obj1) {
27104 {
27105 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27106 if (SWIG_arg_fail(2)) SWIG_fail;
27107 }
27108 }
27109 {
27110 PyThreadState* __tstate = wxPyBeginAllowThreads();
27111 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27112
27113 wxPyEndAllowThreads(__tstate);
27114 if (PyErr_Occurred()) SWIG_fail;
27115 }
27116 resultobj = result;
27117 return resultobj;
27118 fail:
27119 return NULL;
27120 }
27121
27122
27123 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27124 PyObject *resultobj;
27125 wxDataObject *arg1 = (wxDataObject *) 0 ;
27126 wxDataFormat *arg2 = 0 ;
27127 PyObject *result;
27128 PyObject * obj0 = 0 ;
27129 PyObject * obj1 = 0 ;
27130 char *kwnames[] = {
27131 (char *) "self",(char *) "format", NULL
27132 };
27133
27134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27136 if (SWIG_arg_fail(1)) SWIG_fail;
27137 {
27138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(2)) SWIG_fail;
27140 if (arg2 == NULL) {
27141 SWIG_null_ref("wxDataFormat");
27142 }
27143 if (SWIG_arg_fail(2)) SWIG_fail;
27144 }
27145 {
27146 PyThreadState* __tstate = wxPyBeginAllowThreads();
27147 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27148
27149 wxPyEndAllowThreads(__tstate);
27150 if (PyErr_Occurred()) SWIG_fail;
27151 }
27152 resultobj = result;
27153 return resultobj;
27154 fail:
27155 return NULL;
27156 }
27157
27158
27159 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27160 PyObject *resultobj;
27161 wxDataObject *arg1 = (wxDataObject *) 0 ;
27162 wxDataFormat *arg2 = 0 ;
27163 PyObject *arg3 = (PyObject *) 0 ;
27164 bool result;
27165 PyObject * obj0 = 0 ;
27166 PyObject * obj1 = 0 ;
27167 PyObject * obj2 = 0 ;
27168 char *kwnames[] = {
27169 (char *) "self",(char *) "format",(char *) "data", NULL
27170 };
27171
27172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27174 if (SWIG_arg_fail(1)) SWIG_fail;
27175 {
27176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27177 if (SWIG_arg_fail(2)) SWIG_fail;
27178 if (arg2 == NULL) {
27179 SWIG_null_ref("wxDataFormat");
27180 }
27181 if (SWIG_arg_fail(2)) SWIG_fail;
27182 }
27183 arg3 = obj2;
27184 {
27185 PyThreadState* __tstate = wxPyBeginAllowThreads();
27186 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27187
27188 wxPyEndAllowThreads(__tstate);
27189 if (PyErr_Occurred()) SWIG_fail;
27190 }
27191 {
27192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27193 }
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27201 PyObject *obj;
27202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27203 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27204 Py_INCREF(obj);
27205 return Py_BuildValue((char *)"");
27206 }
27207 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27208 PyObject *resultobj;
27209 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27210 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27211 wxDataObjectSimple *result;
27212 PyObject * obj0 = 0 ;
27213 char *kwnames[] = {
27214 (char *) "format", NULL
27215 };
27216
27217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27218 if (obj0) {
27219 {
27220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27221 if (SWIG_arg_fail(1)) SWIG_fail;
27222 if (arg1 == NULL) {
27223 SWIG_null_ref("wxDataFormat");
27224 }
27225 if (SWIG_arg_fail(1)) SWIG_fail;
27226 }
27227 }
27228 {
27229 PyThreadState* __tstate = wxPyBeginAllowThreads();
27230 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27231
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27236 return resultobj;
27237 fail:
27238 return NULL;
27239 }
27240
27241
27242 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27243 PyObject *resultobj;
27244 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27245 wxDataFormat *result;
27246 PyObject * obj0 = 0 ;
27247 char *kwnames[] = {
27248 (char *) "self", NULL
27249 };
27250
27251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27253 if (SWIG_arg_fail(1)) SWIG_fail;
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 {
27257 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27258 result = (wxDataFormat *) &_result_ref;
27259 }
27260
27261 wxPyEndAllowThreads(__tstate);
27262 if (PyErr_Occurred()) SWIG_fail;
27263 }
27264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27272 PyObject *resultobj;
27273 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27274 wxDataFormat *arg2 = 0 ;
27275 PyObject * obj0 = 0 ;
27276 PyObject * obj1 = 0 ;
27277 char *kwnames[] = {
27278 (char *) "self",(char *) "format", NULL
27279 };
27280
27281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27283 if (SWIG_arg_fail(1)) SWIG_fail;
27284 {
27285 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27286 if (SWIG_arg_fail(2)) SWIG_fail;
27287 if (arg2 == NULL) {
27288 SWIG_null_ref("wxDataFormat");
27289 }
27290 if (SWIG_arg_fail(2)) SWIG_fail;
27291 }
27292 {
27293 PyThreadState* __tstate = wxPyBeginAllowThreads();
27294 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27295
27296 wxPyEndAllowThreads(__tstate);
27297 if (PyErr_Occurred()) SWIG_fail;
27298 }
27299 Py_INCREF(Py_None); resultobj = Py_None;
27300 return resultobj;
27301 fail:
27302 return NULL;
27303 }
27304
27305
27306 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27307 PyObject *resultobj;
27308 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27309 size_t result;
27310 PyObject * obj0 = 0 ;
27311 char *kwnames[] = {
27312 (char *) "self", NULL
27313 };
27314
27315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27317 if (SWIG_arg_fail(1)) SWIG_fail;
27318 {
27319 PyThreadState* __tstate = wxPyBeginAllowThreads();
27320 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27321
27322 wxPyEndAllowThreads(__tstate);
27323 if (PyErr_Occurred()) SWIG_fail;
27324 }
27325 {
27326 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27327 }
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj;
27336 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27337 PyObject *result;
27338 PyObject * obj0 = 0 ;
27339 char *kwnames[] = {
27340 (char *) "self", NULL
27341 };
27342
27343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27345 if (SWIG_arg_fail(1)) SWIG_fail;
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27349
27350 wxPyEndAllowThreads(__tstate);
27351 if (PyErr_Occurred()) SWIG_fail;
27352 }
27353 resultobj = result;
27354 return resultobj;
27355 fail:
27356 return NULL;
27357 }
27358
27359
27360 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27361 PyObject *resultobj;
27362 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27363 PyObject *arg2 = (PyObject *) 0 ;
27364 bool result;
27365 PyObject * obj0 = 0 ;
27366 PyObject * obj1 = 0 ;
27367 char *kwnames[] = {
27368 (char *) "self",(char *) "data", NULL
27369 };
27370
27371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27373 if (SWIG_arg_fail(1)) SWIG_fail;
27374 arg2 = obj1;
27375 {
27376 PyThreadState* __tstate = wxPyBeginAllowThreads();
27377 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27378
27379 wxPyEndAllowThreads(__tstate);
27380 if (PyErr_Occurred()) SWIG_fail;
27381 }
27382 {
27383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27384 }
27385 return resultobj;
27386 fail:
27387 return NULL;
27388 }
27389
27390
27391 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27392 PyObject *obj;
27393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27394 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27395 Py_INCREF(obj);
27396 return Py_BuildValue((char *)"");
27397 }
27398 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj;
27400 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27401 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27402 wxPyDataObjectSimple *result;
27403 PyObject * obj0 = 0 ;
27404 char *kwnames[] = {
27405 (char *) "format", NULL
27406 };
27407
27408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27409 if (obj0) {
27410 {
27411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27412 if (SWIG_arg_fail(1)) SWIG_fail;
27413 if (arg1 == NULL) {
27414 SWIG_null_ref("wxDataFormat");
27415 }
27416 if (SWIG_arg_fail(1)) SWIG_fail;
27417 }
27418 }
27419 {
27420 PyThreadState* __tstate = wxPyBeginAllowThreads();
27421 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27422
27423 wxPyEndAllowThreads(__tstate);
27424 if (PyErr_Occurred()) SWIG_fail;
27425 }
27426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj;
27435 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27436 PyObject *arg2 = (PyObject *) 0 ;
27437 PyObject *arg3 = (PyObject *) 0 ;
27438 PyObject * obj0 = 0 ;
27439 PyObject * obj1 = 0 ;
27440 PyObject * obj2 = 0 ;
27441 char *kwnames[] = {
27442 (char *) "self",(char *) "self",(char *) "_class", NULL
27443 };
27444
27445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27447 if (SWIG_arg_fail(1)) SWIG_fail;
27448 arg2 = obj1;
27449 arg3 = obj2;
27450 {
27451 PyThreadState* __tstate = wxPyBeginAllowThreads();
27452 (arg1)->_setCallbackInfo(arg2,arg3);
27453
27454 wxPyEndAllowThreads(__tstate);
27455 if (PyErr_Occurred()) SWIG_fail;
27456 }
27457 Py_INCREF(Py_None); resultobj = Py_None;
27458 return resultobj;
27459 fail:
27460 return NULL;
27461 }
27462
27463
27464 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27465 PyObject *obj;
27466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27467 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27468 Py_INCREF(obj);
27469 return Py_BuildValue((char *)"");
27470 }
27471 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27472 PyObject *resultobj;
27473 wxDataObjectComposite *result;
27474 char *kwnames[] = {
27475 NULL
27476 };
27477
27478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27479 {
27480 PyThreadState* __tstate = wxPyBeginAllowThreads();
27481 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27482
27483 wxPyEndAllowThreads(__tstate);
27484 if (PyErr_Occurred()) SWIG_fail;
27485 }
27486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj;
27495 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27496 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27497 bool arg3 = (bool) false ;
27498 PyObject * obj0 = 0 ;
27499 PyObject * obj1 = 0 ;
27500 PyObject * obj2 = 0 ;
27501 char *kwnames[] = {
27502 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27503 };
27504
27505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27507 if (SWIG_arg_fail(1)) SWIG_fail;
27508 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27509 if (SWIG_arg_fail(2)) SWIG_fail;
27510 if (obj2) {
27511 {
27512 arg3 = (bool)(SWIG_As_bool(obj2));
27513 if (SWIG_arg_fail(3)) SWIG_fail;
27514 }
27515 }
27516 {
27517 PyThreadState* __tstate = wxPyBeginAllowThreads();
27518 (arg1)->Add(arg2,arg3);
27519
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 Py_INCREF(Py_None); resultobj = Py_None;
27524 return resultobj;
27525 fail:
27526 return NULL;
27527 }
27528
27529
27530 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27531 PyObject *obj;
27532 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27533 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27534 Py_INCREF(obj);
27535 return Py_BuildValue((char *)"");
27536 }
27537 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj;
27539 wxString const &arg1_defvalue = wxPyEmptyString ;
27540 wxString *arg1 = (wxString *) &arg1_defvalue ;
27541 wxTextDataObject *result;
27542 bool temp1 = false ;
27543 PyObject * obj0 = 0 ;
27544 char *kwnames[] = {
27545 (char *) "text", NULL
27546 };
27547
27548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27549 if (obj0) {
27550 {
27551 arg1 = wxString_in_helper(obj0);
27552 if (arg1 == NULL) SWIG_fail;
27553 temp1 = true;
27554 }
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27559
27560 wxPyEndAllowThreads(__tstate);
27561 if (PyErr_Occurred()) SWIG_fail;
27562 }
27563 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27564 {
27565 if (temp1)
27566 delete arg1;
27567 }
27568 return resultobj;
27569 fail:
27570 {
27571 if (temp1)
27572 delete arg1;
27573 }
27574 return NULL;
27575 }
27576
27577
27578 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj;
27580 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27581 size_t result;
27582 PyObject * obj0 = 0 ;
27583 char *kwnames[] = {
27584 (char *) "self", NULL
27585 };
27586
27587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27589 if (SWIG_arg_fail(1)) SWIG_fail;
27590 {
27591 PyThreadState* __tstate = wxPyBeginAllowThreads();
27592 result = (size_t)(arg1)->GetTextLength();
27593
27594 wxPyEndAllowThreads(__tstate);
27595 if (PyErr_Occurred()) SWIG_fail;
27596 }
27597 {
27598 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27599 }
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27607 PyObject *resultobj;
27608 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27609 wxString result;
27610 PyObject * obj0 = 0 ;
27611 char *kwnames[] = {
27612 (char *) "self", NULL
27613 };
27614
27615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27617 if (SWIG_arg_fail(1)) SWIG_fail;
27618 {
27619 PyThreadState* __tstate = wxPyBeginAllowThreads();
27620 result = (arg1)->GetText();
27621
27622 wxPyEndAllowThreads(__tstate);
27623 if (PyErr_Occurred()) SWIG_fail;
27624 }
27625 {
27626 #if wxUSE_UNICODE
27627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27628 #else
27629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27630 #endif
27631 }
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27641 wxString *arg2 = 0 ;
27642 bool temp2 = false ;
27643 PyObject * obj0 = 0 ;
27644 PyObject * obj1 = 0 ;
27645 char *kwnames[] = {
27646 (char *) "self",(char *) "text", NULL
27647 };
27648
27649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27651 if (SWIG_arg_fail(1)) SWIG_fail;
27652 {
27653 arg2 = wxString_in_helper(obj1);
27654 if (arg2 == NULL) SWIG_fail;
27655 temp2 = true;
27656 }
27657 {
27658 PyThreadState* __tstate = wxPyBeginAllowThreads();
27659 (arg1)->SetText((wxString const &)*arg2);
27660
27661 wxPyEndAllowThreads(__tstate);
27662 if (PyErr_Occurred()) SWIG_fail;
27663 }
27664 Py_INCREF(Py_None); resultobj = Py_None;
27665 {
27666 if (temp2)
27667 delete arg2;
27668 }
27669 return resultobj;
27670 fail:
27671 {
27672 if (temp2)
27673 delete arg2;
27674 }
27675 return NULL;
27676 }
27677
27678
27679 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27680 PyObject *obj;
27681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27682 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27683 Py_INCREF(obj);
27684 return Py_BuildValue((char *)"");
27685 }
27686 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27687 PyObject *resultobj;
27688 wxString const &arg1_defvalue = wxPyEmptyString ;
27689 wxString *arg1 = (wxString *) &arg1_defvalue ;
27690 wxPyTextDataObject *result;
27691 bool temp1 = false ;
27692 PyObject * obj0 = 0 ;
27693 char *kwnames[] = {
27694 (char *) "text", NULL
27695 };
27696
27697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27698 if (obj0) {
27699 {
27700 arg1 = wxString_in_helper(obj0);
27701 if (arg1 == NULL) SWIG_fail;
27702 temp1 = true;
27703 }
27704 }
27705 {
27706 PyThreadState* __tstate = wxPyBeginAllowThreads();
27707 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27708
27709 wxPyEndAllowThreads(__tstate);
27710 if (PyErr_Occurred()) SWIG_fail;
27711 }
27712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27713 {
27714 if (temp1)
27715 delete arg1;
27716 }
27717 return resultobj;
27718 fail:
27719 {
27720 if (temp1)
27721 delete arg1;
27722 }
27723 return NULL;
27724 }
27725
27726
27727 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27730 PyObject *arg2 = (PyObject *) 0 ;
27731 PyObject *arg3 = (PyObject *) 0 ;
27732 PyObject * obj0 = 0 ;
27733 PyObject * obj1 = 0 ;
27734 PyObject * obj2 = 0 ;
27735 char *kwnames[] = {
27736 (char *) "self",(char *) "self",(char *) "_class", NULL
27737 };
27738
27739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27741 if (SWIG_arg_fail(1)) SWIG_fail;
27742 arg2 = obj1;
27743 arg3 = obj2;
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 (arg1)->_setCallbackInfo(arg2,arg3);
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 Py_INCREF(Py_None); resultobj = Py_None;
27752 return resultobj;
27753 fail:
27754 return NULL;
27755 }
27756
27757
27758 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27759 PyObject *obj;
27760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27761 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27762 Py_INCREF(obj);
27763 return Py_BuildValue((char *)"");
27764 }
27765 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27766 PyObject *resultobj;
27767 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27768 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27769 wxBitmapDataObject *result;
27770 PyObject * obj0 = 0 ;
27771 char *kwnames[] = {
27772 (char *) "bitmap", NULL
27773 };
27774
27775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27776 if (obj0) {
27777 {
27778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27779 if (SWIG_arg_fail(1)) SWIG_fail;
27780 if (arg1 == NULL) {
27781 SWIG_null_ref("wxBitmap");
27782 }
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 }
27785 }
27786 {
27787 PyThreadState* __tstate = wxPyBeginAllowThreads();
27788 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27789
27790 wxPyEndAllowThreads(__tstate);
27791 if (PyErr_Occurred()) SWIG_fail;
27792 }
27793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj;
27802 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27803 wxBitmap result;
27804 PyObject * obj0 = 0 ;
27805 char *kwnames[] = {
27806 (char *) "self", NULL
27807 };
27808
27809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27811 if (SWIG_arg_fail(1)) SWIG_fail;
27812 {
27813 PyThreadState* __tstate = wxPyBeginAllowThreads();
27814 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27815
27816 wxPyEndAllowThreads(__tstate);
27817 if (PyErr_Occurred()) SWIG_fail;
27818 }
27819 {
27820 wxBitmap * resultptr;
27821 resultptr = new wxBitmap((wxBitmap &)(result));
27822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27823 }
27824 return resultobj;
27825 fail:
27826 return NULL;
27827 }
27828
27829
27830 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27831 PyObject *resultobj;
27832 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27833 wxBitmap *arg2 = 0 ;
27834 PyObject * obj0 = 0 ;
27835 PyObject * obj1 = 0 ;
27836 char *kwnames[] = {
27837 (char *) "self",(char *) "bitmap", NULL
27838 };
27839
27840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27842 if (SWIG_arg_fail(1)) SWIG_fail;
27843 {
27844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(2)) SWIG_fail;
27846 if (arg2 == NULL) {
27847 SWIG_null_ref("wxBitmap");
27848 }
27849 if (SWIG_arg_fail(2)) SWIG_fail;
27850 }
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27854
27855 wxPyEndAllowThreads(__tstate);
27856 if (PyErr_Occurred()) SWIG_fail;
27857 }
27858 Py_INCREF(Py_None); resultobj = Py_None;
27859 return resultobj;
27860 fail:
27861 return NULL;
27862 }
27863
27864
27865 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27866 PyObject *obj;
27867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27868 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27869 Py_INCREF(obj);
27870 return Py_BuildValue((char *)"");
27871 }
27872 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27873 PyObject *resultobj;
27874 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27875 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27876 wxPyBitmapDataObject *result;
27877 PyObject * obj0 = 0 ;
27878 char *kwnames[] = {
27879 (char *) "bitmap", NULL
27880 };
27881
27882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27883 if (obj0) {
27884 {
27885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27886 if (SWIG_arg_fail(1)) SWIG_fail;
27887 if (arg1 == NULL) {
27888 SWIG_null_ref("wxBitmap");
27889 }
27890 if (SWIG_arg_fail(1)) SWIG_fail;
27891 }
27892 }
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj;
27909 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27910 PyObject *arg2 = (PyObject *) 0 ;
27911 PyObject *arg3 = (PyObject *) 0 ;
27912 PyObject * obj0 = 0 ;
27913 PyObject * obj1 = 0 ;
27914 PyObject * obj2 = 0 ;
27915 char *kwnames[] = {
27916 (char *) "self",(char *) "self",(char *) "_class", NULL
27917 };
27918
27919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27921 if (SWIG_arg_fail(1)) SWIG_fail;
27922 arg2 = obj1;
27923 arg3 = obj2;
27924 {
27925 PyThreadState* __tstate = wxPyBeginAllowThreads();
27926 (arg1)->_setCallbackInfo(arg2,arg3);
27927
27928 wxPyEndAllowThreads(__tstate);
27929 if (PyErr_Occurred()) SWIG_fail;
27930 }
27931 Py_INCREF(Py_None); resultobj = Py_None;
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27939 PyObject *obj;
27940 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27941 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27942 Py_INCREF(obj);
27943 return Py_BuildValue((char *)"");
27944 }
27945 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27946 PyObject *resultobj;
27947 wxFileDataObject *result;
27948 char *kwnames[] = {
27949 NULL
27950 };
27951
27952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27953 {
27954 PyThreadState* __tstate = wxPyBeginAllowThreads();
27955 result = (wxFileDataObject *)new wxFileDataObject();
27956
27957 wxPyEndAllowThreads(__tstate);
27958 if (PyErr_Occurred()) SWIG_fail;
27959 }
27960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27961 return resultobj;
27962 fail:
27963 return NULL;
27964 }
27965
27966
27967 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27968 PyObject *resultobj;
27969 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27970 wxArrayString *result;
27971 PyObject * obj0 = 0 ;
27972 char *kwnames[] = {
27973 (char *) "self", NULL
27974 };
27975
27976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 {
27982 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27983 result = (wxArrayString *) &_result_ref;
27984 }
27985
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 {
27990 resultobj = wxArrayString2PyList_helper(*result);
27991 }
27992 return resultobj;
27993 fail:
27994 return NULL;
27995 }
27996
27997
27998 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
27999 PyObject *resultobj;
28000 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28001 wxString *arg2 = 0 ;
28002 bool temp2 = false ;
28003 PyObject * obj0 = 0 ;
28004 PyObject * obj1 = 0 ;
28005 char *kwnames[] = {
28006 (char *) "self",(char *) "filename", NULL
28007 };
28008
28009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(1)) SWIG_fail;
28012 {
28013 arg2 = wxString_in_helper(obj1);
28014 if (arg2 == NULL) SWIG_fail;
28015 temp2 = true;
28016 }
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 (arg1)->AddFile((wxString const &)*arg2);
28020
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 Py_INCREF(Py_None); resultobj = Py_None;
28025 {
28026 if (temp2)
28027 delete arg2;
28028 }
28029 return resultobj;
28030 fail:
28031 {
28032 if (temp2)
28033 delete arg2;
28034 }
28035 return NULL;
28036 }
28037
28038
28039 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28040 PyObject *obj;
28041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28042 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28043 Py_INCREF(obj);
28044 return Py_BuildValue((char *)"");
28045 }
28046 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28047 PyObject *resultobj;
28048 wxDataFormat *arg1 = 0 ;
28049 wxCustomDataObject *result;
28050 PyObject * obj0 = 0 ;
28051
28052 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28053 {
28054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28055 if (SWIG_arg_fail(1)) SWIG_fail;
28056 if (arg1 == NULL) {
28057 SWIG_null_ref("wxDataFormat");
28058 }
28059 if (SWIG_arg_fail(1)) SWIG_fail;
28060 }
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28076 PyObject *resultobj;
28077 wxString *arg1 = 0 ;
28078 wxCustomDataObject *result;
28079 bool temp1 = false ;
28080 PyObject * obj0 = 0 ;
28081
28082 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28083 {
28084 arg1 = wxString_in_helper(obj0);
28085 if (arg1 == NULL) SWIG_fail;
28086 temp1 = true;
28087 }
28088 {
28089 PyThreadState* __tstate = wxPyBeginAllowThreads();
28090 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28091
28092 wxPyEndAllowThreads(__tstate);
28093 if (PyErr_Occurred()) SWIG_fail;
28094 }
28095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28096 {
28097 if (temp1)
28098 delete arg1;
28099 }
28100 return resultobj;
28101 fail:
28102 {
28103 if (temp1)
28104 delete arg1;
28105 }
28106 return NULL;
28107 }
28108
28109
28110 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28111 PyObject *resultobj;
28112 wxCustomDataObject *result;
28113
28114 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28115 {
28116 PyThreadState* __tstate = wxPyBeginAllowThreads();
28117 result = (wxCustomDataObject *)new wxCustomDataObject();
28118
28119 wxPyEndAllowThreads(__tstate);
28120 if (PyErr_Occurred()) SWIG_fail;
28121 }
28122 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28123 return resultobj;
28124 fail:
28125 return NULL;
28126 }
28127
28128
28129 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28130 int argc;
28131 PyObject *argv[2];
28132 int ii;
28133
28134 argc = PyObject_Length(args);
28135 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28136 argv[ii] = PyTuple_GetItem(args,ii);
28137 }
28138 if (argc == 0) {
28139 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28140 }
28141 if (argc == 1) {
28142 int _v;
28143 {
28144 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28145 }
28146 if (_v) {
28147 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28148 }
28149 }
28150 if (argc == 1) {
28151 int _v;
28152 {
28153 void *ptr = 0;
28154 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28155 _v = 0;
28156 PyErr_Clear();
28157 } else {
28158 _v = (ptr != 0);
28159 }
28160 }
28161 if (_v) {
28162 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28163 }
28164 }
28165
28166 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28167 return NULL;
28168 }
28169
28170
28171 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28172 PyObject *resultobj;
28173 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28174 PyObject *arg2 = (PyObject *) 0 ;
28175 bool result;
28176 PyObject * obj0 = 0 ;
28177 PyObject * obj1 = 0 ;
28178 char *kwnames[] = {
28179 (char *) "self",(char *) "data", NULL
28180 };
28181
28182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28184 if (SWIG_arg_fail(1)) SWIG_fail;
28185 arg2 = obj1;
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28195 }
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28205 size_t result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (size_t)(arg1)->GetSize();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28233 PyObject *result;
28234 PyObject * obj0 = 0 ;
28235 char *kwnames[] = {
28236 (char *) "self", NULL
28237 };
28238
28239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(1)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28245
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 resultobj = result;
28250 return resultobj;
28251 fail:
28252 return NULL;
28253 }
28254
28255
28256 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28257 PyObject *obj;
28258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28259 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28260 Py_INCREF(obj);
28261 return Py_BuildValue((char *)"");
28262 }
28263 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj;
28265 wxURLDataObject *result;
28266 char *kwnames[] = {
28267 NULL
28268 };
28269
28270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28271 {
28272 PyThreadState* __tstate = wxPyBeginAllowThreads();
28273 result = (wxURLDataObject *)new wxURLDataObject();
28274
28275 wxPyEndAllowThreads(__tstate);
28276 if (PyErr_Occurred()) SWIG_fail;
28277 }
28278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28279 return resultobj;
28280 fail:
28281 return NULL;
28282 }
28283
28284
28285 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28286 PyObject *resultobj;
28287 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28288 wxString result;
28289 PyObject * obj0 = 0 ;
28290 char *kwnames[] = {
28291 (char *) "self", NULL
28292 };
28293
28294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28296 if (SWIG_arg_fail(1)) SWIG_fail;
28297 {
28298 PyThreadState* __tstate = wxPyBeginAllowThreads();
28299 result = (arg1)->GetURL();
28300
28301 wxPyEndAllowThreads(__tstate);
28302 if (PyErr_Occurred()) SWIG_fail;
28303 }
28304 {
28305 #if wxUSE_UNICODE
28306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28307 #else
28308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28309 #endif
28310 }
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28318 PyObject *resultobj;
28319 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28320 wxString *arg2 = 0 ;
28321 bool temp2 = false ;
28322 PyObject * obj0 = 0 ;
28323 PyObject * obj1 = 0 ;
28324 char *kwnames[] = {
28325 (char *) "self",(char *) "url", NULL
28326 };
28327
28328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28330 if (SWIG_arg_fail(1)) SWIG_fail;
28331 {
28332 arg2 = wxString_in_helper(obj1);
28333 if (arg2 == NULL) SWIG_fail;
28334 temp2 = true;
28335 }
28336 {
28337 PyThreadState* __tstate = wxPyBeginAllowThreads();
28338 (arg1)->SetURL((wxString const &)*arg2);
28339
28340 wxPyEndAllowThreads(__tstate);
28341 if (PyErr_Occurred()) SWIG_fail;
28342 }
28343 Py_INCREF(Py_None); resultobj = Py_None;
28344 {
28345 if (temp2)
28346 delete arg2;
28347 }
28348 return resultobj;
28349 fail:
28350 {
28351 if (temp2)
28352 delete arg2;
28353 }
28354 return NULL;
28355 }
28356
28357
28358 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28359 PyObject *obj;
28360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28361 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28362 Py_INCREF(obj);
28363 return Py_BuildValue((char *)"");
28364 }
28365 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28366 PyObject *resultobj;
28367 wxMetafileDataObject *result;
28368 char *kwnames[] = {
28369 NULL
28370 };
28371
28372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28373 {
28374 PyThreadState* __tstate = wxPyBeginAllowThreads();
28375 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28376
28377 wxPyEndAllowThreads(__tstate);
28378 if (PyErr_Occurred()) SWIG_fail;
28379 }
28380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28381 return resultobj;
28382 fail:
28383 return NULL;
28384 }
28385
28386
28387 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28388 PyObject *obj;
28389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28390 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28391 Py_INCREF(obj);
28392 return Py_BuildValue((char *)"");
28393 }
28394 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28395 PyObject *resultobj;
28396 wxDragResult arg1 ;
28397 bool result;
28398 PyObject * obj0 = 0 ;
28399 char *kwnames[] = {
28400 (char *) "res", NULL
28401 };
28402
28403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28404 {
28405 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28406 if (SWIG_arg_fail(1)) SWIG_fail;
28407 }
28408 {
28409 PyThreadState* __tstate = wxPyBeginAllowThreads();
28410 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28411
28412 wxPyEndAllowThreads(__tstate);
28413 if (PyErr_Occurred()) SWIG_fail;
28414 }
28415 {
28416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28417 }
28418 return resultobj;
28419 fail:
28420 return NULL;
28421 }
28422
28423
28424 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28425 PyObject *resultobj;
28426 wxWindow *arg1 = (wxWindow *) 0 ;
28427 wxIcon const &arg2_defvalue = wxNullIcon ;
28428 wxIcon *arg2 = (wxIcon *) &arg2_defvalue ;
28429 wxIcon const &arg3_defvalue = wxNullIcon ;
28430 wxIcon *arg3 = (wxIcon *) &arg3_defvalue ;
28431 wxIcon const &arg4_defvalue = wxNullIcon ;
28432 wxIcon *arg4 = (wxIcon *) &arg4_defvalue ;
28433 wxPyDropSource *result;
28434 PyObject * obj0 = 0 ;
28435 PyObject * obj1 = 0 ;
28436 PyObject * obj2 = 0 ;
28437 PyObject * obj3 = 0 ;
28438 char *kwnames[] = {
28439 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28440 };
28441
28442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28444 if (SWIG_arg_fail(1)) SWIG_fail;
28445 if (obj1) {
28446 {
28447 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28448 if (SWIG_arg_fail(2)) SWIG_fail;
28449 if (arg2 == NULL) {
28450 SWIG_null_ref("wxIcon");
28451 }
28452 if (SWIG_arg_fail(2)) SWIG_fail;
28453 }
28454 }
28455 if (obj2) {
28456 {
28457 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28458 if (SWIG_arg_fail(3)) SWIG_fail;
28459 if (arg3 == NULL) {
28460 SWIG_null_ref("wxIcon");
28461 }
28462 if (SWIG_arg_fail(3)) SWIG_fail;
28463 }
28464 }
28465 if (obj3) {
28466 {
28467 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxIcon, SWIG_POINTER_EXCEPTION | 0);
28468 if (SWIG_arg_fail(4)) SWIG_fail;
28469 if (arg4 == NULL) {
28470 SWIG_null_ref("wxIcon");
28471 }
28472 if (SWIG_arg_fail(4)) SWIG_fail;
28473 }
28474 }
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxIcon const &)*arg2,(wxIcon const &)*arg3,(wxIcon const &)*arg4);
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28490 PyObject *resultobj;
28491 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28492 PyObject *arg2 = (PyObject *) 0 ;
28493 PyObject *arg3 = (PyObject *) 0 ;
28494 int arg4 ;
28495 PyObject * obj0 = 0 ;
28496 PyObject * obj1 = 0 ;
28497 PyObject * obj2 = 0 ;
28498 PyObject * obj3 = 0 ;
28499 char *kwnames[] = {
28500 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28501 };
28502
28503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28505 if (SWIG_arg_fail(1)) SWIG_fail;
28506 arg2 = obj1;
28507 arg3 = obj2;
28508 {
28509 arg4 = (int)(SWIG_As_int(obj3));
28510 if (SWIG_arg_fail(4)) SWIG_fail;
28511 }
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28515
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 Py_INCREF(Py_None); resultobj = Py_None;
28520 return resultobj;
28521 fail:
28522 return NULL;
28523 }
28524
28525
28526 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28527 PyObject *resultobj;
28528 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28529 PyObject * obj0 = 0 ;
28530 char *kwnames[] = {
28531 (char *) "self", NULL
28532 };
28533
28534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28536 if (SWIG_arg_fail(1)) SWIG_fail;
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 delete arg1;
28540
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 Py_INCREF(Py_None); resultobj = Py_None;
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj;
28553 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28554 wxDataObject *arg2 = 0 ;
28555 PyObject * obj0 = 0 ;
28556 PyObject * obj1 = 0 ;
28557 char *kwnames[] = {
28558 (char *) "self",(char *) "data", NULL
28559 };
28560
28561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28563 if (SWIG_arg_fail(1)) SWIG_fail;
28564 {
28565 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28566 if (SWIG_arg_fail(2)) SWIG_fail;
28567 if (arg2 == NULL) {
28568 SWIG_null_ref("wxDataObject");
28569 }
28570 if (SWIG_arg_fail(2)) SWIG_fail;
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->SetData(*arg2);
28575
28576 wxPyEndAllowThreads(__tstate);
28577 if (PyErr_Occurred()) SWIG_fail;
28578 }
28579 Py_INCREF(Py_None); resultobj = Py_None;
28580 return resultobj;
28581 fail:
28582 return NULL;
28583 }
28584
28585
28586 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28587 PyObject *resultobj;
28588 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28589 wxDataObject *result;
28590 PyObject * obj0 = 0 ;
28591 char *kwnames[] = {
28592 (char *) "self", NULL
28593 };
28594
28595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28597 if (SWIG_arg_fail(1)) SWIG_fail;
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 result = (wxDataObject *)(arg1)->GetDataObject();
28601
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28606 return resultobj;
28607 fail:
28608 return NULL;
28609 }
28610
28611
28612 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28613 PyObject *resultobj;
28614 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28615 wxDragResult arg2 ;
28616 wxCursor *arg3 = 0 ;
28617 PyObject * obj0 = 0 ;
28618 PyObject * obj1 = 0 ;
28619 PyObject * obj2 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self",(char *) "res",(char *) "cursor", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28629 if (SWIG_arg_fail(2)) SWIG_fail;
28630 }
28631 {
28632 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28633 if (SWIG_arg_fail(3)) SWIG_fail;
28634 if (arg3 == NULL) {
28635 SWIG_null_ref("wxCursor");
28636 }
28637 if (SWIG_arg_fail(3)) SWIG_fail;
28638 }
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28642
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 Py_INCREF(Py_None); resultobj = Py_None;
28647 return resultobj;
28648 fail:
28649 return NULL;
28650 }
28651
28652
28653 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28654 PyObject *resultobj;
28655 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28656 int arg2 = (int) wxDrag_CopyOnly ;
28657 wxDragResult result;
28658 PyObject * obj0 = 0 ;
28659 PyObject * obj1 = 0 ;
28660 char *kwnames[] = {
28661 (char *) "self",(char *) "flags", NULL
28662 };
28663
28664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28666 if (SWIG_arg_fail(1)) SWIG_fail;
28667 if (obj1) {
28668 {
28669 arg2 = (int)(SWIG_As_int(obj1));
28670 if (SWIG_arg_fail(2)) SWIG_fail;
28671 }
28672 }
28673 {
28674 PyThreadState* __tstate = wxPyBeginAllowThreads();
28675 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28676
28677 wxPyEndAllowThreads(__tstate);
28678 if (PyErr_Occurred()) SWIG_fail;
28679 }
28680 resultobj = SWIG_From_int((result));
28681 return resultobj;
28682 fail:
28683 return NULL;
28684 }
28685
28686
28687 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28688 PyObject *resultobj;
28689 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28690 wxDragResult arg2 ;
28691 bool result;
28692 PyObject * obj0 = 0 ;
28693 PyObject * obj1 = 0 ;
28694 char *kwnames[] = {
28695 (char *) "self",(char *) "effect", NULL
28696 };
28697
28698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28700 if (SWIG_arg_fail(1)) SWIG_fail;
28701 {
28702 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28703 if (SWIG_arg_fail(2)) SWIG_fail;
28704 }
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28708
28709 wxPyEndAllowThreads(__tstate);
28710 if (PyErr_Occurred()) SWIG_fail;
28711 }
28712 {
28713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28714 }
28715 return resultobj;
28716 fail:
28717 return NULL;
28718 }
28719
28720
28721 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28722 PyObject *obj;
28723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28724 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28725 Py_INCREF(obj);
28726 return Py_BuildValue((char *)"");
28727 }
28728 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28729 PyObject *resultobj;
28730 wxDataObject *arg1 = (wxDataObject *) NULL ;
28731 wxPyDropTarget *result;
28732 PyObject * obj0 = 0 ;
28733 char *kwnames[] = {
28734 (char *) "dataObject", NULL
28735 };
28736
28737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28738 if (obj0) {
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 }
28742 {
28743 PyThreadState* __tstate = wxPyBeginAllowThreads();
28744 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28745
28746 wxPyEndAllowThreads(__tstate);
28747 if (PyErr_Occurred()) SWIG_fail;
28748 }
28749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28750 return resultobj;
28751 fail:
28752 return NULL;
28753 }
28754
28755
28756 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28757 PyObject *resultobj;
28758 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28759 PyObject *arg2 = (PyObject *) 0 ;
28760 PyObject *arg3 = (PyObject *) 0 ;
28761 PyObject * obj0 = 0 ;
28762 PyObject * obj1 = 0 ;
28763 PyObject * obj2 = 0 ;
28764 char *kwnames[] = {
28765 (char *) "self",(char *) "self",(char *) "_class", NULL
28766 };
28767
28768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28770 if (SWIG_arg_fail(1)) SWIG_fail;
28771 arg2 = obj1;
28772 arg3 = obj2;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 (arg1)->_setCallbackInfo(arg2,arg3);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 Py_INCREF(Py_None); resultobj = Py_None;
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj;
28789 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28790 PyObject * obj0 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 delete arg1;
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 Py_INCREF(Py_None); resultobj = Py_None;
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28815 wxDataObject *result;
28816 PyObject * obj0 = 0 ;
28817 char *kwnames[] = {
28818 (char *) "self", NULL
28819 };
28820
28821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28823 if (SWIG_arg_fail(1)) SWIG_fail;
28824 {
28825 PyThreadState* __tstate = wxPyBeginAllowThreads();
28826 result = (wxDataObject *)(arg1)->GetDataObject();
28827
28828 wxPyEndAllowThreads(__tstate);
28829 if (PyErr_Occurred()) SWIG_fail;
28830 }
28831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28839 PyObject *resultobj;
28840 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28841 wxDataObject *arg2 = (wxDataObject *) 0 ;
28842 PyObject * obj0 = 0 ;
28843 PyObject * obj1 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self",(char *) "dataObject", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28852 if (SWIG_arg_fail(2)) SWIG_fail;
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 (arg1)->SetDataObject(arg2);
28856
28857 wxPyEndAllowThreads(__tstate);
28858 if (PyErr_Occurred()) SWIG_fail;
28859 }
28860 Py_INCREF(Py_None); resultobj = Py_None;
28861 return resultobj;
28862 fail:
28863 return NULL;
28864 }
28865
28866
28867 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28868 PyObject *resultobj;
28869 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28870 int arg2 ;
28871 int arg3 ;
28872 wxDragResult arg4 ;
28873 wxDragResult result;
28874 PyObject * obj0 = 0 ;
28875 PyObject * obj1 = 0 ;
28876 PyObject * obj2 = 0 ;
28877 PyObject * obj3 = 0 ;
28878 char *kwnames[] = {
28879 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28880 };
28881
28882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28884 if (SWIG_arg_fail(1)) SWIG_fail;
28885 {
28886 arg2 = (int)(SWIG_As_int(obj1));
28887 if (SWIG_arg_fail(2)) SWIG_fail;
28888 }
28889 {
28890 arg3 = (int)(SWIG_As_int(obj2));
28891 if (SWIG_arg_fail(3)) SWIG_fail;
28892 }
28893 {
28894 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28895 if (SWIG_arg_fail(4)) SWIG_fail;
28896 }
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28900
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_From_int((result));
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28912 PyObject *resultobj;
28913 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28914 int arg2 ;
28915 int arg3 ;
28916 wxDragResult arg4 ;
28917 wxDragResult result;
28918 PyObject * obj0 = 0 ;
28919 PyObject * obj1 = 0 ;
28920 PyObject * obj2 = 0 ;
28921 PyObject * obj3 = 0 ;
28922 char *kwnames[] = {
28923 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28924 };
28925
28926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28928 if (SWIG_arg_fail(1)) SWIG_fail;
28929 {
28930 arg2 = (int)(SWIG_As_int(obj1));
28931 if (SWIG_arg_fail(2)) SWIG_fail;
28932 }
28933 {
28934 arg3 = (int)(SWIG_As_int(obj2));
28935 if (SWIG_arg_fail(3)) SWIG_fail;
28936 }
28937 {
28938 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28939 if (SWIG_arg_fail(4)) SWIG_fail;
28940 }
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
28944
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 resultobj = SWIG_From_int((result));
28949 return resultobj;
28950 fail:
28951 return NULL;
28952 }
28953
28954
28955 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
28956 PyObject *resultobj;
28957 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28958 PyObject * obj0 = 0 ;
28959 char *kwnames[] = {
28960 (char *) "self", NULL
28961 };
28962
28963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
28964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28965 if (SWIG_arg_fail(1)) SWIG_fail;
28966 {
28967 PyThreadState* __tstate = wxPyBeginAllowThreads();
28968 (arg1)->base_OnLeave();
28969
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 Py_INCREF(Py_None); resultobj = Py_None;
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28981 PyObject *resultobj;
28982 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28983 int arg2 ;
28984 int arg3 ;
28985 bool result;
28986 PyObject * obj0 = 0 ;
28987 PyObject * obj1 = 0 ;
28988 PyObject * obj2 = 0 ;
28989 char *kwnames[] = {
28990 (char *) "self",(char *) "x",(char *) "y", NULL
28991 };
28992
28993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
28994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28995 if (SWIG_arg_fail(1)) SWIG_fail;
28996 {
28997 arg2 = (int)(SWIG_As_int(obj1));
28998 if (SWIG_arg_fail(2)) SWIG_fail;
28999 }
29000 {
29001 arg3 = (int)(SWIG_As_int(obj2));
29002 if (SWIG_arg_fail(3)) SWIG_fail;
29003 }
29004 {
29005 PyThreadState* __tstate = wxPyBeginAllowThreads();
29006 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29007
29008 wxPyEndAllowThreads(__tstate);
29009 if (PyErr_Occurred()) SWIG_fail;
29010 }
29011 {
29012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29013 }
29014 return resultobj;
29015 fail:
29016 return NULL;
29017 }
29018
29019
29020 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29021 PyObject *resultobj;
29022 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29023 bool result;
29024 PyObject * obj0 = 0 ;
29025 char *kwnames[] = {
29026 (char *) "self", NULL
29027 };
29028
29029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29031 if (SWIG_arg_fail(1)) SWIG_fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (bool)(arg1)->GetData();
29035
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 {
29040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29041 }
29042 return resultobj;
29043 fail:
29044 return NULL;
29045 }
29046
29047
29048 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29049 PyObject *obj;
29050 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29051 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29052 Py_INCREF(obj);
29053 return Py_BuildValue((char *)"");
29054 }
29055 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29056 PyObject *resultobj;
29057 wxPyTextDropTarget *result;
29058 char *kwnames[] = {
29059 NULL
29060 };
29061
29062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj;
29079 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29080 PyObject *arg2 = (PyObject *) 0 ;
29081 PyObject *arg3 = (PyObject *) 0 ;
29082 PyObject * obj0 = 0 ;
29083 PyObject * obj1 = 0 ;
29084 PyObject * obj2 = 0 ;
29085 char *kwnames[] = {
29086 (char *) "self",(char *) "self",(char *) "_class", NULL
29087 };
29088
29089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29091 if (SWIG_arg_fail(1)) SWIG_fail;
29092 arg2 = obj1;
29093 arg3 = obj2;
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 (arg1)->_setCallbackInfo(arg2,arg3);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 Py_INCREF(Py_None); resultobj = Py_None;
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29111 int arg2 ;
29112 int arg3 ;
29113 wxDragResult arg4 ;
29114 wxDragResult result;
29115 PyObject * obj0 = 0 ;
29116 PyObject * obj1 = 0 ;
29117 PyObject * obj2 = 0 ;
29118 PyObject * obj3 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 arg2 = (int)(SWIG_As_int(obj1));
29128 if (SWIG_arg_fail(2)) SWIG_fail;
29129 }
29130 {
29131 arg3 = (int)(SWIG_As_int(obj2));
29132 if (SWIG_arg_fail(3)) SWIG_fail;
29133 }
29134 {
29135 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29136 if (SWIG_arg_fail(4)) SWIG_fail;
29137 }
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 resultobj = SWIG_From_int((result));
29146 return resultobj;
29147 fail:
29148 return NULL;
29149 }
29150
29151
29152 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj;
29154 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29155 int arg2 ;
29156 int arg3 ;
29157 wxDragResult arg4 ;
29158 wxDragResult result;
29159 PyObject * obj0 = 0 ;
29160 PyObject * obj1 = 0 ;
29161 PyObject * obj2 = 0 ;
29162 PyObject * obj3 = 0 ;
29163 char *kwnames[] = {
29164 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29165 };
29166
29167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29169 if (SWIG_arg_fail(1)) SWIG_fail;
29170 {
29171 arg2 = (int)(SWIG_As_int(obj1));
29172 if (SWIG_arg_fail(2)) SWIG_fail;
29173 }
29174 {
29175 arg3 = (int)(SWIG_As_int(obj2));
29176 if (SWIG_arg_fail(3)) SWIG_fail;
29177 }
29178 {
29179 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29180 if (SWIG_arg_fail(4)) SWIG_fail;
29181 }
29182 {
29183 PyThreadState* __tstate = wxPyBeginAllowThreads();
29184 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29185
29186 wxPyEndAllowThreads(__tstate);
29187 if (PyErr_Occurred()) SWIG_fail;
29188 }
29189 resultobj = SWIG_From_int((result));
29190 return resultobj;
29191 fail:
29192 return NULL;
29193 }
29194
29195
29196 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29197 PyObject *resultobj;
29198 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29199 PyObject * obj0 = 0 ;
29200 char *kwnames[] = {
29201 (char *) "self", NULL
29202 };
29203
29204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29206 if (SWIG_arg_fail(1)) SWIG_fail;
29207 {
29208 PyThreadState* __tstate = wxPyBeginAllowThreads();
29209 (arg1)->base_OnLeave();
29210
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 Py_INCREF(Py_None); resultobj = Py_None;
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29222 PyObject *resultobj;
29223 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29224 int arg2 ;
29225 int arg3 ;
29226 bool result;
29227 PyObject * obj0 = 0 ;
29228 PyObject * obj1 = 0 ;
29229 PyObject * obj2 = 0 ;
29230 char *kwnames[] = {
29231 (char *) "self",(char *) "x",(char *) "y", NULL
29232 };
29233
29234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29236 if (SWIG_arg_fail(1)) SWIG_fail;
29237 {
29238 arg2 = (int)(SWIG_As_int(obj1));
29239 if (SWIG_arg_fail(2)) SWIG_fail;
29240 }
29241 {
29242 arg3 = (int)(SWIG_As_int(obj2));
29243 if (SWIG_arg_fail(3)) SWIG_fail;
29244 }
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29248
29249 wxPyEndAllowThreads(__tstate);
29250 if (PyErr_Occurred()) SWIG_fail;
29251 }
29252 {
29253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29254 }
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj;
29263 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29264 int arg2 ;
29265 int arg3 ;
29266 wxDragResult arg4 ;
29267 wxDragResult result;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 PyObject * obj2 = 0 ;
29271 PyObject * obj3 = 0 ;
29272 char *kwnames[] = {
29273 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29274 };
29275
29276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29278 if (SWIG_arg_fail(1)) SWIG_fail;
29279 {
29280 arg2 = (int)(SWIG_As_int(obj1));
29281 if (SWIG_arg_fail(2)) SWIG_fail;
29282 }
29283 {
29284 arg3 = (int)(SWIG_As_int(obj2));
29285 if (SWIG_arg_fail(3)) SWIG_fail;
29286 }
29287 {
29288 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29289 if (SWIG_arg_fail(4)) SWIG_fail;
29290 }
29291 {
29292 PyThreadState* __tstate = wxPyBeginAllowThreads();
29293 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29294
29295 wxPyEndAllowThreads(__tstate);
29296 if (PyErr_Occurred()) SWIG_fail;
29297 }
29298 resultobj = SWIG_From_int((result));
29299 return resultobj;
29300 fail:
29301 return NULL;
29302 }
29303
29304
29305 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29306 PyObject *obj;
29307 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29308 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29309 Py_INCREF(obj);
29310 return Py_BuildValue((char *)"");
29311 }
29312 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj;
29314 wxPyFileDropTarget *result;
29315 char *kwnames[] = {
29316 NULL
29317 };
29318
29319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29320 {
29321 PyThreadState* __tstate = wxPyBeginAllowThreads();
29322 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29323
29324 wxPyEndAllowThreads(__tstate);
29325 if (PyErr_Occurred()) SWIG_fail;
29326 }
29327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29328 return resultobj;
29329 fail:
29330 return NULL;
29331 }
29332
29333
29334 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29335 PyObject *resultobj;
29336 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29337 PyObject *arg2 = (PyObject *) 0 ;
29338 PyObject *arg3 = (PyObject *) 0 ;
29339 PyObject * obj0 = 0 ;
29340 PyObject * obj1 = 0 ;
29341 PyObject * obj2 = 0 ;
29342 char *kwnames[] = {
29343 (char *) "self",(char *) "self",(char *) "_class", NULL
29344 };
29345
29346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29348 if (SWIG_arg_fail(1)) SWIG_fail;
29349 arg2 = obj1;
29350 arg3 = obj2;
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 (arg1)->_setCallbackInfo(arg2,arg3);
29354
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 Py_INCREF(Py_None); resultobj = Py_None;
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj;
29367 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29368 int arg2 ;
29369 int arg3 ;
29370 wxDragResult arg4 ;
29371 wxDragResult result;
29372 PyObject * obj0 = 0 ;
29373 PyObject * obj1 = 0 ;
29374 PyObject * obj2 = 0 ;
29375 PyObject * obj3 = 0 ;
29376 char *kwnames[] = {
29377 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29378 };
29379
29380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29382 if (SWIG_arg_fail(1)) SWIG_fail;
29383 {
29384 arg2 = (int)(SWIG_As_int(obj1));
29385 if (SWIG_arg_fail(2)) SWIG_fail;
29386 }
29387 {
29388 arg3 = (int)(SWIG_As_int(obj2));
29389 if (SWIG_arg_fail(3)) SWIG_fail;
29390 }
29391 {
29392 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29393 if (SWIG_arg_fail(4)) SWIG_fail;
29394 }
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29398
29399 wxPyEndAllowThreads(__tstate);
29400 if (PyErr_Occurred()) SWIG_fail;
29401 }
29402 resultobj = SWIG_From_int((result));
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29410 PyObject *resultobj;
29411 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29412 int arg2 ;
29413 int arg3 ;
29414 wxDragResult arg4 ;
29415 wxDragResult result;
29416 PyObject * obj0 = 0 ;
29417 PyObject * obj1 = 0 ;
29418 PyObject * obj2 = 0 ;
29419 PyObject * obj3 = 0 ;
29420 char *kwnames[] = {
29421 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29422 };
29423
29424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29426 if (SWIG_arg_fail(1)) SWIG_fail;
29427 {
29428 arg2 = (int)(SWIG_As_int(obj1));
29429 if (SWIG_arg_fail(2)) SWIG_fail;
29430 }
29431 {
29432 arg3 = (int)(SWIG_As_int(obj2));
29433 if (SWIG_arg_fail(3)) SWIG_fail;
29434 }
29435 {
29436 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29437 if (SWIG_arg_fail(4)) SWIG_fail;
29438 }
29439 {
29440 PyThreadState* __tstate = wxPyBeginAllowThreads();
29441 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29442
29443 wxPyEndAllowThreads(__tstate);
29444 if (PyErr_Occurred()) SWIG_fail;
29445 }
29446 resultobj = SWIG_From_int((result));
29447 return resultobj;
29448 fail:
29449 return NULL;
29450 }
29451
29452
29453 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29454 PyObject *resultobj;
29455 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29456 PyObject * obj0 = 0 ;
29457 char *kwnames[] = {
29458 (char *) "self", NULL
29459 };
29460
29461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29463 if (SWIG_arg_fail(1)) SWIG_fail;
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 (arg1)->base_OnLeave();
29467
29468 wxPyEndAllowThreads(__tstate);
29469 if (PyErr_Occurred()) SWIG_fail;
29470 }
29471 Py_INCREF(Py_None); resultobj = Py_None;
29472 return resultobj;
29473 fail:
29474 return NULL;
29475 }
29476
29477
29478 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29479 PyObject *resultobj;
29480 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29481 int arg2 ;
29482 int arg3 ;
29483 bool result;
29484 PyObject * obj0 = 0 ;
29485 PyObject * obj1 = 0 ;
29486 PyObject * obj2 = 0 ;
29487 char *kwnames[] = {
29488 (char *) "self",(char *) "x",(char *) "y", NULL
29489 };
29490
29491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29493 if (SWIG_arg_fail(1)) SWIG_fail;
29494 {
29495 arg2 = (int)(SWIG_As_int(obj1));
29496 if (SWIG_arg_fail(2)) SWIG_fail;
29497 }
29498 {
29499 arg3 = (int)(SWIG_As_int(obj2));
29500 if (SWIG_arg_fail(3)) SWIG_fail;
29501 }
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 {
29510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29511 }
29512 return resultobj;
29513 fail:
29514 return NULL;
29515 }
29516
29517
29518 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29519 PyObject *resultobj;
29520 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29521 int arg2 ;
29522 int arg3 ;
29523 wxDragResult arg4 ;
29524 wxDragResult result;
29525 PyObject * obj0 = 0 ;
29526 PyObject * obj1 = 0 ;
29527 PyObject * obj2 = 0 ;
29528 PyObject * obj3 = 0 ;
29529 char *kwnames[] = {
29530 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29531 };
29532
29533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29535 if (SWIG_arg_fail(1)) SWIG_fail;
29536 {
29537 arg2 = (int)(SWIG_As_int(obj1));
29538 if (SWIG_arg_fail(2)) SWIG_fail;
29539 }
29540 {
29541 arg3 = (int)(SWIG_As_int(obj2));
29542 if (SWIG_arg_fail(3)) SWIG_fail;
29543 }
29544 {
29545 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29546 if (SWIG_arg_fail(4)) SWIG_fail;
29547 }
29548 {
29549 PyThreadState* __tstate = wxPyBeginAllowThreads();
29550 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29551
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_From_int((result));
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29563 PyObject *obj;
29564 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29565 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29566 Py_INCREF(obj);
29567 return Py_BuildValue((char *)"");
29568 }
29569 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj;
29571 wxClipboard *result;
29572 char *kwnames[] = {
29573 NULL
29574 };
29575
29576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29577 {
29578 PyThreadState* __tstate = wxPyBeginAllowThreads();
29579 result = (wxClipboard *)new wxClipboard();
29580
29581 wxPyEndAllowThreads(__tstate);
29582 if (PyErr_Occurred()) SWIG_fail;
29583 }
29584 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29585 return resultobj;
29586 fail:
29587 return NULL;
29588 }
29589
29590
29591 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29592 PyObject *resultobj;
29593 wxClipboard *arg1 = (wxClipboard *) 0 ;
29594 PyObject * obj0 = 0 ;
29595 char *kwnames[] = {
29596 (char *) "self", NULL
29597 };
29598
29599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29601 if (SWIG_arg_fail(1)) SWIG_fail;
29602 {
29603 PyThreadState* __tstate = wxPyBeginAllowThreads();
29604 delete arg1;
29605
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 Py_INCREF(Py_None); resultobj = Py_None;
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj;
29618 wxClipboard *arg1 = (wxClipboard *) 0 ;
29619 bool result;
29620 PyObject * obj0 = 0 ;
29621 char *kwnames[] = {
29622 (char *) "self", NULL
29623 };
29624
29625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29627 if (SWIG_arg_fail(1)) SWIG_fail;
29628 {
29629 PyThreadState* __tstate = wxPyBeginAllowThreads();
29630 result = (bool)(arg1)->Open();
29631
29632 wxPyEndAllowThreads(__tstate);
29633 if (PyErr_Occurred()) SWIG_fail;
29634 }
29635 {
29636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29637 }
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj;
29646 wxClipboard *arg1 = (wxClipboard *) 0 ;
29647 PyObject * obj0 = 0 ;
29648 char *kwnames[] = {
29649 (char *) "self", NULL
29650 };
29651
29652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29654 if (SWIG_arg_fail(1)) SWIG_fail;
29655 {
29656 PyThreadState* __tstate = wxPyBeginAllowThreads();
29657 (arg1)->Close();
29658
29659 wxPyEndAllowThreads(__tstate);
29660 if (PyErr_Occurred()) SWIG_fail;
29661 }
29662 Py_INCREF(Py_None); resultobj = Py_None;
29663 return resultobj;
29664 fail:
29665 return NULL;
29666 }
29667
29668
29669 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29670 PyObject *resultobj;
29671 wxClipboard *arg1 = (wxClipboard *) 0 ;
29672 bool result;
29673 PyObject * obj0 = 0 ;
29674 char *kwnames[] = {
29675 (char *) "self", NULL
29676 };
29677
29678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29680 if (SWIG_arg_fail(1)) SWIG_fail;
29681 {
29682 PyThreadState* __tstate = wxPyBeginAllowThreads();
29683 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29684
29685 wxPyEndAllowThreads(__tstate);
29686 if (PyErr_Occurred()) SWIG_fail;
29687 }
29688 {
29689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29690 }
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj;
29699 wxClipboard *arg1 = (wxClipboard *) 0 ;
29700 wxDataObject *arg2 = (wxDataObject *) 0 ;
29701 bool result;
29702 PyObject * obj0 = 0 ;
29703 PyObject * obj1 = 0 ;
29704 char *kwnames[] = {
29705 (char *) "self",(char *) "data", NULL
29706 };
29707
29708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29710 if (SWIG_arg_fail(1)) SWIG_fail;
29711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29712 if (SWIG_arg_fail(2)) SWIG_fail;
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (bool)(arg1)->AddData(arg2);
29716
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 {
29721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29722 }
29723 return resultobj;
29724 fail:
29725 return NULL;
29726 }
29727
29728
29729 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29730 PyObject *resultobj;
29731 wxClipboard *arg1 = (wxClipboard *) 0 ;
29732 wxDataObject *arg2 = (wxDataObject *) 0 ;
29733 bool result;
29734 PyObject * obj0 = 0 ;
29735 PyObject * obj1 = 0 ;
29736 char *kwnames[] = {
29737 (char *) "self",(char *) "data", NULL
29738 };
29739
29740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29742 if (SWIG_arg_fail(1)) SWIG_fail;
29743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29744 if (SWIG_arg_fail(2)) SWIG_fail;
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 result = (bool)(arg1)->SetData(arg2);
29748
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 {
29753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29754 }
29755 return resultobj;
29756 fail:
29757 return NULL;
29758 }
29759
29760
29761 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29762 PyObject *resultobj;
29763 wxClipboard *arg1 = (wxClipboard *) 0 ;
29764 wxDataFormat *arg2 = 0 ;
29765 bool result;
29766 PyObject * obj0 = 0 ;
29767 PyObject * obj1 = 0 ;
29768 char *kwnames[] = {
29769 (char *) "self",(char *) "format", NULL
29770 };
29771
29772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29774 if (SWIG_arg_fail(1)) SWIG_fail;
29775 {
29776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29777 if (SWIG_arg_fail(2)) SWIG_fail;
29778 if (arg2 == NULL) {
29779 SWIG_null_ref("wxDataFormat");
29780 }
29781 if (SWIG_arg_fail(2)) SWIG_fail;
29782 }
29783 {
29784 PyThreadState* __tstate = wxPyBeginAllowThreads();
29785 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29786
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29792 }
29793 return resultobj;
29794 fail:
29795 return NULL;
29796 }
29797
29798
29799 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29800 PyObject *resultobj;
29801 wxClipboard *arg1 = (wxClipboard *) 0 ;
29802 wxDataObject *arg2 = 0 ;
29803 bool result;
29804 PyObject * obj0 = 0 ;
29805 PyObject * obj1 = 0 ;
29806 char *kwnames[] = {
29807 (char *) "self",(char *) "data", NULL
29808 };
29809
29810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29812 if (SWIG_arg_fail(1)) SWIG_fail;
29813 {
29814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29815 if (SWIG_arg_fail(2)) SWIG_fail;
29816 if (arg2 == NULL) {
29817 SWIG_null_ref("wxDataObject");
29818 }
29819 if (SWIG_arg_fail(2)) SWIG_fail;
29820 }
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = (bool)(arg1)->GetData(*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_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29838 PyObject *resultobj;
29839 wxClipboard *arg1 = (wxClipboard *) 0 ;
29840 PyObject * obj0 = 0 ;
29841 char *kwnames[] = {
29842 (char *) "self", NULL
29843 };
29844
29845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29847 if (SWIG_arg_fail(1)) SWIG_fail;
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 (arg1)->Clear();
29851
29852 wxPyEndAllowThreads(__tstate);
29853 if (PyErr_Occurred()) SWIG_fail;
29854 }
29855 Py_INCREF(Py_None); resultobj = Py_None;
29856 return resultobj;
29857 fail:
29858 return NULL;
29859 }
29860
29861
29862 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29863 PyObject *resultobj;
29864 wxClipboard *arg1 = (wxClipboard *) 0 ;
29865 bool result;
29866 PyObject * obj0 = 0 ;
29867 char *kwnames[] = {
29868 (char *) "self", NULL
29869 };
29870
29871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29873 if (SWIG_arg_fail(1)) SWIG_fail;
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 result = (bool)(arg1)->Flush();
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 {
29882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29883 }
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29891 PyObject *resultobj;
29892 wxClipboard *arg1 = (wxClipboard *) 0 ;
29893 bool arg2 = (bool) true ;
29894 PyObject * obj0 = 0 ;
29895 PyObject * obj1 = 0 ;
29896 char *kwnames[] = {
29897 (char *) "self",(char *) "primary", NULL
29898 };
29899
29900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29902 if (SWIG_arg_fail(1)) SWIG_fail;
29903 if (obj1) {
29904 {
29905 arg2 = (bool)(SWIG_As_bool(obj1));
29906 if (SWIG_arg_fail(2)) SWIG_fail;
29907 }
29908 }
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 (arg1)->UsePrimarySelection(arg2);
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 Py_INCREF(Py_None); resultobj = Py_None;
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj;
29925 wxClipboard *result;
29926 char *kwnames[] = {
29927 NULL
29928 };
29929
29930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
29931 {
29932 PyThreadState* __tstate = wxPyBeginAllowThreads();
29933 result = (wxClipboard *)wxClipboard::Get();
29934
29935 wxPyEndAllowThreads(__tstate);
29936 if (PyErr_Occurred()) SWIG_fail;
29937 }
29938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
29939 return resultobj;
29940 fail:
29941 return NULL;
29942 }
29943
29944
29945 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
29946 PyObject *obj;
29947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29948 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
29949 Py_INCREF(obj);
29950 return Py_BuildValue((char *)"");
29951 }
29952 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxClipboard *arg1 = (wxClipboard *) NULL ;
29955 wxClipboardLocker *result;
29956 PyObject * obj0 = 0 ;
29957 char *kwnames[] = {
29958 (char *) "clipboard", NULL
29959 };
29960
29961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
29962 if (obj0) {
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 }
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
29969
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
29981 PyObject *resultobj;
29982 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
29983 PyObject * obj0 = 0 ;
29984 char *kwnames[] = {
29985 (char *) "self", NULL
29986 };
29987
29988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
29989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
29990 if (SWIG_arg_fail(1)) SWIG_fail;
29991 {
29992 PyThreadState* __tstate = wxPyBeginAllowThreads();
29993 delete arg1;
29994
29995 wxPyEndAllowThreads(__tstate);
29996 if (PyErr_Occurred()) SWIG_fail;
29997 }
29998 Py_INCREF(Py_None); resultobj = Py_None;
29999 return resultobj;
30000 fail:
30001 return NULL;
30002 }
30003
30004
30005 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30006 PyObject *resultobj;
30007 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30008 bool result;
30009 PyObject * obj0 = 0 ;
30010 char *kwnames[] = {
30011 (char *) "self", NULL
30012 };
30013
30014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30016 if (SWIG_arg_fail(1)) SWIG_fail;
30017 {
30018 PyThreadState* __tstate = wxPyBeginAllowThreads();
30019 result = (bool)wxClipboardLocker___nonzero__(arg1);
30020
30021 wxPyEndAllowThreads(__tstate);
30022 if (PyErr_Occurred()) SWIG_fail;
30023 }
30024 {
30025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30026 }
30027 return resultobj;
30028 fail:
30029 return NULL;
30030 }
30031
30032
30033 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30034 PyObject *obj;
30035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30036 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30037 Py_INCREF(obj);
30038 return Py_BuildValue((char *)"");
30039 }
30040 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30041 PyObject *resultobj;
30042 int arg1 = (int) 0 ;
30043 int arg2 = (int) 0 ;
30044 int arg3 = (int) 0 ;
30045 int arg4 = (int) 0 ;
30046 wxVideoMode *result;
30047 PyObject * obj0 = 0 ;
30048 PyObject * obj1 = 0 ;
30049 PyObject * obj2 = 0 ;
30050 PyObject * obj3 = 0 ;
30051 char *kwnames[] = {
30052 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30053 };
30054
30055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30056 if (obj0) {
30057 {
30058 arg1 = (int)(SWIG_As_int(obj0));
30059 if (SWIG_arg_fail(1)) SWIG_fail;
30060 }
30061 }
30062 if (obj1) {
30063 {
30064 arg2 = (int)(SWIG_As_int(obj1));
30065 if (SWIG_arg_fail(2)) SWIG_fail;
30066 }
30067 }
30068 if (obj2) {
30069 {
30070 arg3 = (int)(SWIG_As_int(obj2));
30071 if (SWIG_arg_fail(3)) SWIG_fail;
30072 }
30073 }
30074 if (obj3) {
30075 {
30076 arg4 = (int)(SWIG_As_int(obj3));
30077 if (SWIG_arg_fail(4)) SWIG_fail;
30078 }
30079 }
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30083
30084 wxPyEndAllowThreads(__tstate);
30085 if (PyErr_Occurred()) SWIG_fail;
30086 }
30087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30088 return resultobj;
30089 fail:
30090 return NULL;
30091 }
30092
30093
30094 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30095 PyObject *resultobj;
30096 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30097 PyObject * obj0 = 0 ;
30098 char *kwnames[] = {
30099 (char *) "self", NULL
30100 };
30101
30102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30104 if (SWIG_arg_fail(1)) SWIG_fail;
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 delete arg1;
30108
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 Py_INCREF(Py_None); resultobj = Py_None;
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj;
30121 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30122 wxVideoMode *arg2 = 0 ;
30123 bool result;
30124 PyObject * obj0 = 0 ;
30125 PyObject * obj1 = 0 ;
30126 char *kwnames[] = {
30127 (char *) "self",(char *) "other", NULL
30128 };
30129
30130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30132 if (SWIG_arg_fail(1)) SWIG_fail;
30133 {
30134 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30135 if (SWIG_arg_fail(2)) SWIG_fail;
30136 if (arg2 == NULL) {
30137 SWIG_null_ref("wxVideoMode");
30138 }
30139 if (SWIG_arg_fail(2)) SWIG_fail;
30140 }
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 {
30149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30150 }
30151 return resultobj;
30152 fail:
30153 return NULL;
30154 }
30155
30156
30157 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30158 PyObject *resultobj;
30159 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30160 int result;
30161 PyObject * obj0 = 0 ;
30162 char *kwnames[] = {
30163 (char *) "self", NULL
30164 };
30165
30166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30168 if (SWIG_arg_fail(1)) SWIG_fail;
30169 {
30170 PyThreadState* __tstate = wxPyBeginAllowThreads();
30171 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30172
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 {
30177 resultobj = SWIG_From_int((int)(result));
30178 }
30179 return resultobj;
30180 fail:
30181 return NULL;
30182 }
30183
30184
30185 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30186 PyObject *resultobj;
30187 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30188 int result;
30189 PyObject * obj0 = 0 ;
30190 char *kwnames[] = {
30191 (char *) "self", NULL
30192 };
30193
30194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30196 if (SWIG_arg_fail(1)) SWIG_fail;
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30200
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 {
30205 resultobj = SWIG_From_int((int)(result));
30206 }
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30214 PyObject *resultobj;
30215 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30216 int result;
30217 PyObject * obj0 = 0 ;
30218 char *kwnames[] = {
30219 (char *) "self", NULL
30220 };
30221
30222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30228
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 {
30233 resultobj = SWIG_From_int((int)(result));
30234 }
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj;
30243 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30244 bool result;
30245 PyObject * obj0 = 0 ;
30246 char *kwnames[] = {
30247 (char *) "self", NULL
30248 };
30249
30250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30252 if (SWIG_arg_fail(1)) SWIG_fail;
30253 {
30254 PyThreadState* __tstate = wxPyBeginAllowThreads();
30255 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30256
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 {
30261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30262 }
30263 return resultobj;
30264 fail:
30265 return NULL;
30266 }
30267
30268
30269 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30270 PyObject *resultobj;
30271 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30272 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30273 bool result;
30274 PyObject * obj0 = 0 ;
30275 PyObject * obj1 = 0 ;
30276 char *kwnames[] = {
30277 (char *) "self",(char *) "other", NULL
30278 };
30279
30280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30282 if (SWIG_arg_fail(1)) SWIG_fail;
30283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30284 if (SWIG_arg_fail(2)) SWIG_fail;
30285 {
30286 PyThreadState* __tstate = wxPyBeginAllowThreads();
30287 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30288
30289 wxPyEndAllowThreads(__tstate);
30290 if (PyErr_Occurred()) SWIG_fail;
30291 }
30292 {
30293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30294 }
30295 return resultobj;
30296 fail:
30297 return NULL;
30298 }
30299
30300
30301 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30302 PyObject *resultobj;
30303 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30304 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30305 bool result;
30306 PyObject * obj0 = 0 ;
30307 PyObject * obj1 = 0 ;
30308 char *kwnames[] = {
30309 (char *) "self",(char *) "other", NULL
30310 };
30311
30312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30314 if (SWIG_arg_fail(1)) SWIG_fail;
30315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30316 if (SWIG_arg_fail(2)) SWIG_fail;
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30320
30321 wxPyEndAllowThreads(__tstate);
30322 if (PyErr_Occurred()) SWIG_fail;
30323 }
30324 {
30325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30326 }
30327 return resultobj;
30328 fail:
30329 return NULL;
30330 }
30331
30332
30333 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30334 PyObject *resultobj;
30335 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30336 int arg2 ;
30337 PyObject * obj0 = 0 ;
30338 PyObject * obj1 = 0 ;
30339 char *kwnames[] = {
30340 (char *) "self",(char *) "w", NULL
30341 };
30342
30343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30345 if (SWIG_arg_fail(1)) SWIG_fail;
30346 {
30347 arg2 = (int)(SWIG_As_int(obj1));
30348 if (SWIG_arg_fail(2)) SWIG_fail;
30349 }
30350 if (arg1) (arg1)->w = arg2;
30351
30352 Py_INCREF(Py_None); resultobj = Py_None;
30353 return resultobj;
30354 fail:
30355 return NULL;
30356 }
30357
30358
30359 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30360 PyObject *resultobj;
30361 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30362 int result;
30363 PyObject * obj0 = 0 ;
30364 char *kwnames[] = {
30365 (char *) "self", NULL
30366 };
30367
30368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30370 if (SWIG_arg_fail(1)) SWIG_fail;
30371 result = (int) ((arg1)->w);
30372
30373 {
30374 resultobj = SWIG_From_int((int)(result));
30375 }
30376 return resultobj;
30377 fail:
30378 return NULL;
30379 }
30380
30381
30382 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30383 PyObject *resultobj;
30384 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30385 int arg2 ;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 char *kwnames[] = {
30389 (char *) "self",(char *) "h", NULL
30390 };
30391
30392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30394 if (SWIG_arg_fail(1)) SWIG_fail;
30395 {
30396 arg2 = (int)(SWIG_As_int(obj1));
30397 if (SWIG_arg_fail(2)) SWIG_fail;
30398 }
30399 if (arg1) (arg1)->h = arg2;
30400
30401 Py_INCREF(Py_None); resultobj = Py_None;
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30409 PyObject *resultobj;
30410 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30411 int result;
30412 PyObject * obj0 = 0 ;
30413 char *kwnames[] = {
30414 (char *) "self", NULL
30415 };
30416
30417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30419 if (SWIG_arg_fail(1)) SWIG_fail;
30420 result = (int) ((arg1)->h);
30421
30422 {
30423 resultobj = SWIG_From_int((int)(result));
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj;
30433 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30434 int arg2 ;
30435 PyObject * obj0 = 0 ;
30436 PyObject * obj1 = 0 ;
30437 char *kwnames[] = {
30438 (char *) "self",(char *) "bpp", NULL
30439 };
30440
30441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30443 if (SWIG_arg_fail(1)) SWIG_fail;
30444 {
30445 arg2 = (int)(SWIG_As_int(obj1));
30446 if (SWIG_arg_fail(2)) SWIG_fail;
30447 }
30448 if (arg1) (arg1)->bpp = arg2;
30449
30450 Py_INCREF(Py_None); resultobj = Py_None;
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj;
30459 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30460 int result;
30461 PyObject * obj0 = 0 ;
30462 char *kwnames[] = {
30463 (char *) "self", NULL
30464 };
30465
30466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30468 if (SWIG_arg_fail(1)) SWIG_fail;
30469 result = (int) ((arg1)->bpp);
30470
30471 {
30472 resultobj = SWIG_From_int((int)(result));
30473 }
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj;
30482 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30483 int arg2 ;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 char *kwnames[] = {
30487 (char *) "self",(char *) "refresh", NULL
30488 };
30489
30490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30492 if (SWIG_arg_fail(1)) SWIG_fail;
30493 {
30494 arg2 = (int)(SWIG_As_int(obj1));
30495 if (SWIG_arg_fail(2)) SWIG_fail;
30496 }
30497 if (arg1) (arg1)->refresh = arg2;
30498
30499 Py_INCREF(Py_None); resultobj = Py_None;
30500 return resultobj;
30501 fail:
30502 return NULL;
30503 }
30504
30505
30506 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30507 PyObject *resultobj;
30508 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30509 int result;
30510 PyObject * obj0 = 0 ;
30511 char *kwnames[] = {
30512 (char *) "self", NULL
30513 };
30514
30515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30517 if (SWIG_arg_fail(1)) SWIG_fail;
30518 result = (int) ((arg1)->refresh);
30519
30520 {
30521 resultobj = SWIG_From_int((int)(result));
30522 }
30523 return resultobj;
30524 fail:
30525 return NULL;
30526 }
30527
30528
30529 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30530 PyObject *obj;
30531 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30532 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30533 Py_INCREF(obj);
30534 return Py_BuildValue((char *)"");
30535 }
30536 static int _wrap_DefaultVideoMode_set(PyObject *) {
30537 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30538 return 1;
30539 }
30540
30541
30542 static PyObject *_wrap_DefaultVideoMode_get(void) {
30543 PyObject *pyobj;
30544
30545 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30546 return pyobj;
30547 }
30548
30549
30550 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj;
30552 size_t arg1 = (size_t) 0 ;
30553 wxDisplay *result;
30554 PyObject * obj0 = 0 ;
30555 char *kwnames[] = {
30556 (char *) "index", NULL
30557 };
30558
30559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30560 if (obj0) {
30561 {
30562 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30563 if (SWIG_arg_fail(1)) SWIG_fail;
30564 }
30565 }
30566 {
30567 PyThreadState* __tstate = wxPyBeginAllowThreads();
30568 result = (wxDisplay *)new wxDisplay(arg1);
30569
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj;
30582 wxDisplay *arg1 = (wxDisplay *) 0 ;
30583 PyObject * obj0 = 0 ;
30584 char *kwnames[] = {
30585 (char *) "self", NULL
30586 };
30587
30588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30590 if (SWIG_arg_fail(1)) SWIG_fail;
30591 {
30592 PyThreadState* __tstate = wxPyBeginAllowThreads();
30593 delete arg1;
30594
30595 wxPyEndAllowThreads(__tstate);
30596 if (PyErr_Occurred()) SWIG_fail;
30597 }
30598 Py_INCREF(Py_None); resultobj = Py_None;
30599 return resultobj;
30600 fail:
30601 return NULL;
30602 }
30603
30604
30605 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30606 PyObject *resultobj;
30607 size_t result;
30608 char *kwnames[] = {
30609 NULL
30610 };
30611
30612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30613 {
30614 PyThreadState* __tstate = wxPyBeginAllowThreads();
30615 result = (size_t)wxDisplay::GetCount();
30616
30617 wxPyEndAllowThreads(__tstate);
30618 if (PyErr_Occurred()) SWIG_fail;
30619 }
30620 {
30621 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30622 }
30623 return resultobj;
30624 fail:
30625 return NULL;
30626 }
30627
30628
30629 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30630 PyObject *resultobj;
30631 wxPoint *arg1 = 0 ;
30632 int result;
30633 wxPoint temp1 ;
30634 PyObject * obj0 = 0 ;
30635 char *kwnames[] = {
30636 (char *) "pt", NULL
30637 };
30638
30639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30640 {
30641 arg1 = &temp1;
30642 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30643 }
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30647
30648 wxPyEndAllowThreads(__tstate);
30649 if (PyErr_Occurred()) SWIG_fail;
30650 }
30651 {
30652 resultobj = SWIG_From_int((int)(result));
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 int result;
30664 PyObject * obj0 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "window", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (int)Display_GetFromWindow(arg1);
30675
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 {
30680 resultobj = SWIG_From_int((int)(result));
30681 }
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30689 PyObject *resultobj;
30690 wxDisplay *arg1 = (wxDisplay *) 0 ;
30691 bool result;
30692 PyObject * obj0 = 0 ;
30693 char *kwnames[] = {
30694 (char *) "self", NULL
30695 };
30696
30697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30699 if (SWIG_arg_fail(1)) SWIG_fail;
30700 {
30701 PyThreadState* __tstate = wxPyBeginAllowThreads();
30702 result = (bool)((wxDisplay const *)arg1)->IsOk();
30703
30704 wxPyEndAllowThreads(__tstate);
30705 if (PyErr_Occurred()) SWIG_fail;
30706 }
30707 {
30708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30709 }
30710 return resultobj;
30711 fail:
30712 return NULL;
30713 }
30714
30715
30716 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30717 PyObject *resultobj;
30718 wxDisplay *arg1 = (wxDisplay *) 0 ;
30719 wxRect result;
30720 PyObject * obj0 = 0 ;
30721 char *kwnames[] = {
30722 (char *) "self", NULL
30723 };
30724
30725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30727 if (SWIG_arg_fail(1)) SWIG_fail;
30728 {
30729 PyThreadState* __tstate = wxPyBeginAllowThreads();
30730 result = ((wxDisplay const *)arg1)->GetGeometry();
30731
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 {
30736 wxRect * resultptr;
30737 resultptr = new wxRect((wxRect &)(result));
30738 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30747 PyObject *resultobj;
30748 wxDisplay *arg1 = (wxDisplay *) 0 ;
30749 wxString result;
30750 PyObject * obj0 = 0 ;
30751 char *kwnames[] = {
30752 (char *) "self", NULL
30753 };
30754
30755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30757 if (SWIG_arg_fail(1)) SWIG_fail;
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 result = ((wxDisplay const *)arg1)->GetName();
30761
30762 wxPyEndAllowThreads(__tstate);
30763 if (PyErr_Occurred()) SWIG_fail;
30764 }
30765 {
30766 #if wxUSE_UNICODE
30767 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30768 #else
30769 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30770 #endif
30771 }
30772 return resultobj;
30773 fail:
30774 return NULL;
30775 }
30776
30777
30778 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30779 PyObject *resultobj;
30780 wxDisplay *arg1 = (wxDisplay *) 0 ;
30781 bool result;
30782 PyObject * obj0 = 0 ;
30783 char *kwnames[] = {
30784 (char *) "self", NULL
30785 };
30786
30787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30789 if (SWIG_arg_fail(1)) SWIG_fail;
30790 {
30791 PyThreadState* __tstate = wxPyBeginAllowThreads();
30792 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30793
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 {
30798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30799 }
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj;
30808 wxDisplay *arg1 = (wxDisplay *) 0 ;
30809 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30810 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30811 PyObject *result;
30812 PyObject * obj0 = 0 ;
30813 PyObject * obj1 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self",(char *) "mode", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 if (obj1) {
30822 {
30823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30824 if (SWIG_arg_fail(2)) SWIG_fail;
30825 if (arg2 == NULL) {
30826 SWIG_null_ref("wxVideoMode");
30827 }
30828 if (SWIG_arg_fail(2)) SWIG_fail;
30829 }
30830 }
30831 {
30832 PyThreadState* __tstate = wxPyBeginAllowThreads();
30833 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30834
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 resultobj = result;
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj;
30847 wxDisplay *arg1 = (wxDisplay *) 0 ;
30848 wxVideoMode result;
30849 PyObject * obj0 = 0 ;
30850 char *kwnames[] = {
30851 (char *) "self", NULL
30852 };
30853
30854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30856 if (SWIG_arg_fail(1)) SWIG_fail;
30857 {
30858 PyThreadState* __tstate = wxPyBeginAllowThreads();
30859 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30860
30861 wxPyEndAllowThreads(__tstate);
30862 if (PyErr_Occurred()) SWIG_fail;
30863 }
30864 {
30865 wxVideoMode * resultptr;
30866 resultptr = new wxVideoMode((wxVideoMode &)(result));
30867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30876 PyObject *resultobj;
30877 wxDisplay *arg1 = (wxDisplay *) 0 ;
30878 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30879 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30880 bool result;
30881 PyObject * obj0 = 0 ;
30882 PyObject * obj1 = 0 ;
30883 char *kwnames[] = {
30884 (char *) "self",(char *) "mode", NULL
30885 };
30886
30887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30889 if (SWIG_arg_fail(1)) SWIG_fail;
30890 if (obj1) {
30891 {
30892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30893 if (SWIG_arg_fail(2)) SWIG_fail;
30894 if (arg2 == NULL) {
30895 SWIG_null_ref("wxVideoMode");
30896 }
30897 if (SWIG_arg_fail(2)) SWIG_fail;
30898 }
30899 }
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30903
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 {
30908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30909 }
30910 return resultobj;
30911 fail:
30912 return NULL;
30913 }
30914
30915
30916 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30917 PyObject *resultobj;
30918 wxDisplay *arg1 = (wxDisplay *) 0 ;
30919 PyObject * obj0 = 0 ;
30920 char *kwnames[] = {
30921 (char *) "self", NULL
30922 };
30923
30924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
30925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30926 if (SWIG_arg_fail(1)) SWIG_fail;
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 (arg1)->ResetMode();
30930
30931 wxPyEndAllowThreads(__tstate);
30932 if (PyErr_Occurred()) SWIG_fail;
30933 }
30934 Py_INCREF(Py_None); resultobj = Py_None;
30935 return resultobj;
30936 fail:
30937 return NULL;
30938 }
30939
30940
30941 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
30942 PyObject *obj;
30943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30944 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
30945 Py_INCREF(obj);
30946 return Py_BuildValue((char *)"");
30947 }
30948 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj;
30950 wxStandardPaths *result;
30951 char *kwnames[] = {
30952 NULL
30953 };
30954
30955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
30956 {
30957 PyThreadState* __tstate = wxPyBeginAllowThreads();
30958 result = (wxStandardPaths *)StandardPaths_Get();
30959
30960 wxPyEndAllowThreads(__tstate);
30961 if (PyErr_Occurred()) SWIG_fail;
30962 }
30963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj;
30972 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
30973 wxString result;
30974 PyObject * obj0 = 0 ;
30975 char *kwnames[] = {
30976 (char *) "self", NULL
30977 };
30978
30979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
30980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
30981 if (SWIG_arg_fail(1)) SWIG_fail;
30982 {
30983 PyThreadState* __tstate = wxPyBeginAllowThreads();
30984 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
30985
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 {
30990 #if wxUSE_UNICODE
30991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30992 #else
30993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30994 #endif
30995 }
30996 return resultobj;
30997 fail:
30998 return NULL;
30999 }
31000
31001
31002 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31003 PyObject *resultobj;
31004 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31005 wxString result;
31006 PyObject * obj0 = 0 ;
31007 char *kwnames[] = {
31008 (char *) "self", NULL
31009 };
31010
31011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31013 if (SWIG_arg_fail(1)) SWIG_fail;
31014 {
31015 PyThreadState* __tstate = wxPyBeginAllowThreads();
31016 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31017
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 {
31022 #if wxUSE_UNICODE
31023 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31024 #else
31025 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31026 #endif
31027 }
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj;
31036 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31037 wxString result;
31038 PyObject * obj0 = 0 ;
31039 char *kwnames[] = {
31040 (char *) "self", NULL
31041 };
31042
31043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31045 if (SWIG_arg_fail(1)) SWIG_fail;
31046 {
31047 PyThreadState* __tstate = wxPyBeginAllowThreads();
31048 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31049
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 {
31054 #if wxUSE_UNICODE
31055 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31056 #else
31057 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31058 #endif
31059 }
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31067 PyObject *resultobj;
31068 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31069 wxString result;
31070 PyObject * obj0 = 0 ;
31071 char *kwnames[] = {
31072 (char *) "self", NULL
31073 };
31074
31075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31077 if (SWIG_arg_fail(1)) SWIG_fail;
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31081
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 {
31086 #if wxUSE_UNICODE
31087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31088 #else
31089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31090 #endif
31091 }
31092 return resultobj;
31093 fail:
31094 return NULL;
31095 }
31096
31097
31098 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31099 PyObject *resultobj;
31100 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31101 wxString result;
31102 PyObject * obj0 = 0 ;
31103 char *kwnames[] = {
31104 (char *) "self", NULL
31105 };
31106
31107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31109 if (SWIG_arg_fail(1)) SWIG_fail;
31110 {
31111 PyThreadState* __tstate = wxPyBeginAllowThreads();
31112 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31113
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 {
31118 #if wxUSE_UNICODE
31119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31120 #else
31121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31122 #endif
31123 }
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31131 PyObject *resultobj;
31132 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31133 wxString result;
31134 PyObject * obj0 = 0 ;
31135 char *kwnames[] = {
31136 (char *) "self", NULL
31137 };
31138
31139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31141 if (SWIG_arg_fail(1)) SWIG_fail;
31142 {
31143 PyThreadState* __tstate = wxPyBeginAllowThreads();
31144 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31145
31146 wxPyEndAllowThreads(__tstate);
31147 if (PyErr_Occurred()) SWIG_fail;
31148 }
31149 {
31150 #if wxUSE_UNICODE
31151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31152 #else
31153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31154 #endif
31155 }
31156 return resultobj;
31157 fail:
31158 return NULL;
31159 }
31160
31161
31162 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31163 PyObject *resultobj;
31164 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31165 wxString result;
31166 PyObject * obj0 = 0 ;
31167 char *kwnames[] = {
31168 (char *) "self", NULL
31169 };
31170
31171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31173 if (SWIG_arg_fail(1)) SWIG_fail;
31174 {
31175 PyThreadState* __tstate = wxPyBeginAllowThreads();
31176 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31177
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 {
31182 #if wxUSE_UNICODE
31183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31184 #else
31185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31186 #endif
31187 }
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31195 PyObject *resultobj;
31196 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31197 wxString *arg2 = 0 ;
31198 bool temp2 = false ;
31199 PyObject * obj0 = 0 ;
31200 PyObject * obj1 = 0 ;
31201 char *kwnames[] = {
31202 (char *) "self",(char *) "prefix", NULL
31203 };
31204
31205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31207 if (SWIG_arg_fail(1)) SWIG_fail;
31208 {
31209 arg2 = wxString_in_helper(obj1);
31210 if (arg2 == NULL) SWIG_fail;
31211 temp2 = true;
31212 }
31213 {
31214 PyThreadState* __tstate = wxPyBeginAllowThreads();
31215 (arg1)->SetInstallPrefix((wxString const &)*arg2);
31216
31217 wxPyEndAllowThreads(__tstate);
31218 if (PyErr_Occurred()) SWIG_fail;
31219 }
31220 Py_INCREF(Py_None); resultobj = Py_None;
31221 {
31222 if (temp2)
31223 delete arg2;
31224 }
31225 return resultobj;
31226 fail:
31227 {
31228 if (temp2)
31229 delete arg2;
31230 }
31231 return NULL;
31232 }
31233
31234
31235 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31236 PyObject *resultobj;
31237 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31238 wxString result;
31239 PyObject * obj0 = 0 ;
31240 char *kwnames[] = {
31241 (char *) "self", NULL
31242 };
31243
31244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31246 if (SWIG_arg_fail(1)) SWIG_fail;
31247 {
31248 PyThreadState* __tstate = wxPyBeginAllowThreads();
31249 result = ((wxStandardPaths const *)arg1)->GetInstallPrefix();
31250
31251 wxPyEndAllowThreads(__tstate);
31252 if (PyErr_Occurred()) SWIG_fail;
31253 }
31254 {
31255 #if wxUSE_UNICODE
31256 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31257 #else
31258 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31259 #endif
31260 }
31261 return resultobj;
31262 fail:
31263 return NULL;
31264 }
31265
31266
31267 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31268 PyObject *obj;
31269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31270 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31271 Py_INCREF(obj);
31272 return Py_BuildValue((char *)"");
31273 }
31274 static PyMethodDef SwigMethods[] = {
31275 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31276 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31277 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31278 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31279 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31280 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31281 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31282 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31283 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31284 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31285 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31286 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31287 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31288 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31289 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31290 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31291 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31292 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31293 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31294 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31295 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31296 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31297 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31298 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31299 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31300 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31301 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31302 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31303 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31304 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31305 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31306 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31307 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31308 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31309 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31310 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31311 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31312 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31313 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31314 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31315 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31316 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31317 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31318 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31319 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31320 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31321 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31322 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31323 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31324 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31325 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31326 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31327 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31328 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31329 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31330 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31331 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31332 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31333 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31334 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31335 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31336 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31337 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31338 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31339 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31340 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31341 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31342 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31343 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31344 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31345 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31346 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31347 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31348 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31349 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31350 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31351 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31352 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31353 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31359 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31361 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31366 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31379 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31382 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31385 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31388 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31394 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31408 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31414 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31420 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31423 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31437 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31440 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31441 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31444 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31459 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31471 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31473 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31475 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31477 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31484 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31485 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31490 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31491 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31500 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31504 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31508 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31511 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31514 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31528 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31536 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31550 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31581 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31583 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31601 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31611 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31627 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31643 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31657 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31666 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31709 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31712 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31715 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31719 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31812 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31813 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31814 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31815 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31832 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31877 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31911 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31919 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31920 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
31925 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
31934 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
31941 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
31944 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
31947 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
31952 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
31955 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
31959 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
31962 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
31966 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
31967 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
31971 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
31975 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
31977 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
31987 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
31998 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32006 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32014 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32018 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32028 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32032 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32048 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32050 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32064 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32066 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32075 { NULL, NULL, 0, NULL }
32076 };
32077
32078
32079 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32080
32081 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32082 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32083 }
32084 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32085 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32086 }
32087 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32088 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32089 }
32090 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32091 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32092 }
32093 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32094 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32095 }
32096 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32097 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32098 }
32099 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32100 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32101 }
32102 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32103 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32104 }
32105 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32106 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32107 }
32108 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32109 return (void *)((wxEvent *) ((wxPyEvent *) x));
32110 }
32111 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32112 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32113 }
32114 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32115 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32116 }
32117 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32118 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32119 }
32120 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32121 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32122 }
32123 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32124 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32125 }
32126 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32127 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32128 }
32129 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32130 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32131 }
32132 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32133 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32134 }
32135 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32136 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32137 }
32138 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32139 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32140 }
32141 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32142 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32143 }
32144 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32145 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32146 }
32147 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32148 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32149 }
32150 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32151 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32152 }
32153 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32154 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32155 }
32156 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32157 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32158 }
32159 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32160 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32161 }
32162 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32163 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32164 }
32165 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32166 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32167 }
32168 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32169 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32170 }
32171 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32172 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32173 }
32174 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32175 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32176 }
32177 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32178 return (void *)((wxEvent *) ((wxShowEvent *) x));
32179 }
32180 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32181 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32182 }
32183 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32184 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32185 }
32186 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32187 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32188 }
32189 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32190 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32191 }
32192 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32193 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32194 }
32195 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32196 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32197 }
32198 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32199 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32200 }
32201 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32202 return (void *)((wxConfigBase *) ((wxConfig *) x));
32203 }
32204 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32205 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32206 }
32207 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32208 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32209 }
32210 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32211 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32212 }
32213 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32214 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32215 }
32216 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32217 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32218 }
32219 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32220 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32221 }
32222 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32223 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32224 }
32225 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32226 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32227 }
32228 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32229 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32230 }
32231 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32232 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32233 }
32234 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32235 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32236 }
32237 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32238 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32239 }
32240 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32241 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32242 }
32243 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32244 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32245 }
32246 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32247 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32248 }
32249 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32250 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32251 }
32252 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32253 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32254 }
32255 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32256 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32257 }
32258 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32259 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32260 }
32261 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32262 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32263 }
32264 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32265 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32266 }
32267 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32268 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32269 }
32270 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32271 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32272 }
32273 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32274 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32275 }
32276 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32277 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32278 }
32279 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32280 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32281 }
32282 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32283 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32284 }
32285 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32286 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32287 }
32288 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32289 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32290 }
32291 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32292 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32293 }
32294 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32295 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32296 }
32297 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32298 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32299 }
32300 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32301 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32302 }
32303 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32304 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32305 }
32306 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32307 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32308 }
32309 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32310 return (void *)((wxObject *) ((wxSizerItem *) x));
32311 }
32312 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32314 }
32315 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32316 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32317 }
32318 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32319 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32320 }
32321 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32322 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32323 }
32324 static void *_p_wxSizerTo_p_wxObject(void *x) {
32325 return (void *)((wxObject *) ((wxSizer *) x));
32326 }
32327 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32328 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32329 }
32330 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32331 return (void *)((wxObject *) ((wxFileHistory *) x));
32332 }
32333 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32334 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32335 }
32336 static void *_p_wxEventTo_p_wxObject(void *x) {
32337 return (void *)((wxObject *) ((wxEvent *) x));
32338 }
32339 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32340 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32341 }
32342 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32343 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32344 }
32345 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32346 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32347 }
32348 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32349 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32350 }
32351 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32352 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32353 }
32354 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32355 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32356 }
32357 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32358 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32359 }
32360 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32361 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32362 }
32363 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32364 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32365 }
32366 static void *_p_wxControlTo_p_wxObject(void *x) {
32367 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32368 }
32369 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32370 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32371 }
32372 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32373 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32374 }
32375 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32376 return (void *)((wxObject *) ((wxFSFile *) x));
32377 }
32378 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32379 return (void *)((wxObject *) ((wxClipboard *) x));
32380 }
32381 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32382 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32383 }
32384 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32385 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32386 }
32387 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32388 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32389 }
32390 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32391 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32392 }
32393 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32394 return (void *)((wxObject *) ((wxToolTip *) x));
32395 }
32396 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32397 return (void *)((wxObject *) ((wxMenuItem *) x));
32398 }
32399 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32400 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32401 }
32402 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32403 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32404 }
32405 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32407 }
32408 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32409 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32410 }
32411 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32412 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32413 }
32414 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32415 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32416 }
32417 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32418 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32419 }
32420 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32421 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32422 }
32423 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32424 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32425 }
32426 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32427 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32428 }
32429 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32430 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32431 }
32432 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32433 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32434 }
32435 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32436 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32437 }
32438 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32439 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32440 }
32441 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32442 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32443 }
32444 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32445 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32446 }
32447 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32448 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32449 }
32450 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32451 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32452 }
32453 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32454 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32455 }
32456 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32457 return (void *)((wxObject *) ((wxImageHandler *) x));
32458 }
32459 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32460 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32461 }
32462 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32463 return (void *)((wxObject *) ((wxEvtHandler *) x));
32464 }
32465 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32466 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32467 }
32468 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32469 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32470 }
32471 static void *_p_wxImageTo_p_wxObject(void *x) {
32472 return (void *)((wxObject *) ((wxImage *) x));
32473 }
32474 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32475 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32476 }
32477 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32478 return (void *)((wxObject *) ((wxSystemOptions *) x));
32479 }
32480 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32481 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32482 }
32483 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32485 }
32486 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32487 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32488 }
32489 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32490 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32491 }
32492 static void *_p_wxWindowTo_p_wxObject(void *x) {
32493 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32494 }
32495 static void *_p_wxMenuTo_p_wxObject(void *x) {
32496 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32497 }
32498 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32499 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32500 }
32501 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32502 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32503 }
32504 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32505 return (void *)((wxObject *) ((wxFileSystem *) x));
32506 }
32507 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32508 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32509 }
32510 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32511 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32512 }
32513 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32514 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32515 }
32516 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32517 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32518 }
32519 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32520 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32521 }
32522 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32523 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32524 }
32525 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32526 return (void *)((wxObject *) ((wxBusyInfo *) x));
32527 }
32528 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32529 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32530 }
32531 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32532 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32533 }
32534 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32535 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32536 }
32537 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32538 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32539 }
32540 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32542 }
32543 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32544 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32545 }
32546 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32547 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32548 }
32549 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32550 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32551 }
32552 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32553 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32554 }
32555 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32556 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32557 }
32558 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32559 return (void *)((wxLog *) ((wxLogStderr *) x));
32560 }
32561 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32562 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32563 }
32564 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32565 return (void *)((wxLog *) ((wxLogWindow *) x));
32566 }
32567 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32568 return (void *)((wxLog *) ((wxLogChain *) x));
32569 }
32570 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32571 return (void *)((wxLog *) ((wxLogGui *) x));
32572 }
32573 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32574 return (void *)((wxLog *) ((wxPyLog *) x));
32575 }
32576 static void *_p_wxControlTo_p_wxWindow(void *x) {
32577 return (void *)((wxWindow *) ((wxControl *) x));
32578 }
32579 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32580 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32581 }
32582 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32583 return (void *)((wxWindow *) ((wxMenuBar *) x));
32584 }
32585 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32586 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32587 }
32588 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32589 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32590 }
32591 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}};
32592 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}};
32593 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}};
32594 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}};
32595 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}};
32596 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}};
32597 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}};
32598 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}};
32599 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}};
32600 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}};
32601 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}};
32602 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}};
32603 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}};
32604 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}};
32605 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}};
32606 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}};
32607 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}};
32608 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}};
32609 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}};
32610 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}};
32611 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}};
32612 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}};
32613 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}};
32614 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}};
32615 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}};
32616 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}};
32617 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}};
32618 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}};
32619 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}};
32620 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}};
32621 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}};
32622 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}};
32623 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}};
32624 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}};
32625 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}};
32626 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}};
32627 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}};
32628 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}};
32629 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}};
32630 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}};
32631 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}};
32632 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}};
32633 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}};
32634 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}};
32635 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}};
32636 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}};
32637 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}};
32638 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}};
32639 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}};
32640 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}};
32641 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}};
32642 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}};
32643 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}};
32644 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}};
32645 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}};
32646 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}};
32647 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}};
32648 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}};
32649 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}};
32650 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}};
32651 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}};
32652 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}};
32653 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}};
32654 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}};
32655 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}};
32656 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}};
32657 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}};
32658 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}};
32659 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}};
32660 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}};
32661 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}};
32662 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}};
32663 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}};
32664 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}};
32665 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}};
32666 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}};
32667 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}};
32668 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}};
32669 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}};
32670 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}};
32671 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}};
32672 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}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687
32688 static swig_type_info *swig_types_initial[] = {
32689 _swigt__p_wxLogChain,
32690 _swigt__p_wxMutexGuiLocker,
32691 _swigt__p_wxFileHistory,
32692 _swigt__p_wxLog,
32693 _swigt__p_wxMenu,
32694 _swigt__p_wxEvent,
32695 _swigt__p_wxDateTime__TimeZone,
32696 _swigt__p_wxConfigBase,
32697 _swigt__p_wxDisplay,
32698 _swigt__p_wxFileType,
32699 _swigt__p_wxLogGui,
32700 _swigt__p_wxFont,
32701 _swigt__p_wxDataFormat,
32702 _swigt__p_wxTimerEvent,
32703 _swigt__p_wxCaret,
32704 _swigt__ptrdiff_t,
32705 _swigt__std__ptrdiff_t,
32706 _swigt__p_int,
32707 _swigt__p_wxSize,
32708 _swigt__p_wxClipboard,
32709 _swigt__p_wxStopWatch,
32710 _swigt__p_wxDC,
32711 _swigt__p_wxClipboardLocker,
32712 _swigt__p_wxIcon,
32713 _swigt__p_wxLogStderr,
32714 _swigt__p_wxLogTextCtrl,
32715 _swigt__p_wxTextCtrl,
32716 _swigt__p_wxBusyCursor,
32717 _swigt__p_wxBitmapDataObject,
32718 _swigt__p_wxTextDataObject,
32719 _swigt__p_wxDataObject,
32720 _swigt__p_wxPyTextDataObject,
32721 _swigt__p_wxPyBitmapDataObject,
32722 _swigt__p_wxFileDataObject,
32723 _swigt__p_wxCustomDataObject,
32724 _swigt__p_wxURLDataObject,
32725 _swigt__p_wxMetafileDataObject,
32726 _swigt__p_wxSound,
32727 _swigt__p_wxTimerRunner,
32728 _swigt__p_wxLogWindow,
32729 _swigt__p_wxTimeSpan,
32730 _swigt__p_wxArrayString,
32731 _swigt__p_wxWindowDisabler,
32732 _swigt__p_form_ops_t,
32733 _swigt__p_wxToolTip,
32734 _swigt__p_wxDataObjectComposite,
32735 _swigt__p_wxSystemSettings,
32736 _swigt__p_wxFileConfig,
32737 _swigt__p_wxVideoMode,
32738 _swigt__p_wxDataObjectSimple,
32739 _swigt__p_wxPyDataObjectSimple,
32740 _swigt__p_wxDuplexMode,
32741 _swigt__p_wxEvtHandler,
32742 _swigt__p_wxRect,
32743 _swigt__p_char,
32744 _swigt__p_wxSingleInstanceChecker,
32745 _swigt__p_wxStandardPaths,
32746 _swigt__p_wxFileTypeInfo,
32747 _swigt__p_wxFrame,
32748 _swigt__p_wxTimer,
32749 _swigt__p_wxPaperSize,
32750 _swigt__p_wxMimeTypesManager,
32751 _swigt__p_wxPyArtProvider,
32752 _swigt__p_wxPyTipProvider,
32753 _swigt__p_wxTipProvider,
32754 _swigt__p_wxJoystick,
32755 _swigt__p_wxSystemOptions,
32756 _swigt__p_wxPoint,
32757 _swigt__p_wxJoystickEvent,
32758 _swigt__p_wxCursor,
32759 _swigt__p_wxObject,
32760 _swigt__p_wxOutputStream,
32761 _swigt__p_wxDateTime,
32762 _swigt__p_wxPyDropSource,
32763 _swigt__p_unsigned_long,
32764 _swigt__p_wxKillError,
32765 _swigt__p_wxWindow,
32766 _swigt__p_wxString,
32767 _swigt__p_wxPyProcess,
32768 _swigt__p_wxBitmap,
32769 _swigt__p_wxConfig,
32770 _swigt__unsigned_int,
32771 _swigt__p_unsigned_int,
32772 _swigt__p_unsigned_char,
32773 _swigt__p_wxChar,
32774 _swigt__p_wxBusyInfo,
32775 _swigt__p_wxPyDropTarget,
32776 _swigt__p_wxPyTextDropTarget,
32777 _swigt__p_wxPyFileDropTarget,
32778 _swigt__p_wxProcessEvent,
32779 _swigt__p_wxPyLog,
32780 _swigt__p_wxLogNull,
32781 _swigt__p_wxColour,
32782 _swigt__p_wxPyTimer,
32783 _swigt__p_wxConfigPathChanger,
32784 _swigt__p_wxDateSpan,
32785 0
32786 };
32787
32788
32789 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32790
32791 static swig_const_info swig_const_table[] = {
32792 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32793 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32794 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32795 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32796 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32797 {0, 0, 0, 0.0, 0, 0}};
32798
32799 #ifdef __cplusplus
32800 }
32801 #endif
32802
32803
32804 #ifdef __cplusplus
32805 extern "C" {
32806 #endif
32807
32808 /* Python-specific SWIG API */
32809 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32810 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32811 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32812
32813 /* -----------------------------------------------------------------------------
32814 * global variable support code.
32815 * ----------------------------------------------------------------------------- */
32816
32817 typedef struct swig_globalvar {
32818 char *name; /* Name of global variable */
32819 PyObject *(*get_attr)(); /* Return the current value */
32820 int (*set_attr)(PyObject *); /* Set the value */
32821 struct swig_globalvar *next;
32822 } swig_globalvar;
32823
32824 typedef struct swig_varlinkobject {
32825 PyObject_HEAD
32826 swig_globalvar *vars;
32827 } swig_varlinkobject;
32828
32829 static PyObject *
32830 swig_varlink_repr(swig_varlinkobject *v) {
32831 v = v;
32832 return PyString_FromString("<Swig global variables>");
32833 }
32834
32835 static int
32836 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32837 swig_globalvar *var;
32838 flags = flags;
32839 fprintf(fp,"Swig global variables { ");
32840 for (var = v->vars; var; var=var->next) {
32841 fprintf(fp,"%s", var->name);
32842 if (var->next) fprintf(fp,", ");
32843 }
32844 fprintf(fp," }\n");
32845 return 0;
32846 }
32847
32848 static PyObject *
32849 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32850 swig_globalvar *var = v->vars;
32851 while (var) {
32852 if (strcmp(var->name,n) == 0) {
32853 return (*var->get_attr)();
32854 }
32855 var = var->next;
32856 }
32857 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32858 return NULL;
32859 }
32860
32861 static int
32862 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32863 swig_globalvar *var = v->vars;
32864 while (var) {
32865 if (strcmp(var->name,n) == 0) {
32866 return (*var->set_attr)(p);
32867 }
32868 var = var->next;
32869 }
32870 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32871 return 1;
32872 }
32873
32874 static PyTypeObject varlinktype = {
32875 PyObject_HEAD_INIT(0)
32876 0, /* Number of items in variable part (ob_size) */
32877 (char *)"swigvarlink", /* Type name (tp_name) */
32878 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32879 0, /* Itemsize (tp_itemsize) */
32880 0, /* Deallocator (tp_dealloc) */
32881 (printfunc) swig_varlink_print, /* Print (tp_print) */
32882 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32883 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32884 0, /* tp_compare */
32885 (reprfunc) swig_varlink_repr, /* tp_repr */
32886 0, /* tp_as_number */
32887 0, /* tp_as_sequence */
32888 0, /* tp_as_mapping */
32889 0, /* tp_hash */
32890 0, /* tp_call */
32891 0, /* tp_str */
32892 0, /* tp_getattro */
32893 0, /* tp_setattro */
32894 0, /* tp_as_buffer */
32895 0, /* tp_flags */
32896 0, /* tp_doc */
32897 #if PY_VERSION_HEX >= 0x02000000
32898 0, /* tp_traverse */
32899 0, /* tp_clear */
32900 #endif
32901 #if PY_VERSION_HEX >= 0x02010000
32902 0, /* tp_richcompare */
32903 0, /* tp_weaklistoffset */
32904 #endif
32905 #if PY_VERSION_HEX >= 0x02020000
32906 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32907 #endif
32908 #if PY_VERSION_HEX >= 0x02030000
32909 0, /* tp_del */
32910 #endif
32911 #ifdef COUNT_ALLOCS
32912 0,0,0,0 /* tp_alloc -> tp_next */
32913 #endif
32914 };
32915
32916 /* Create a variable linking object for use later */
32917 static PyObject *
32918 SWIG_Python_newvarlink(void) {
32919 swig_varlinkobject *result = 0;
32920 result = PyMem_NEW(swig_varlinkobject,1);
32921 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
32922 result->ob_type = &varlinktype;
32923 result->vars = 0;
32924 result->ob_refcnt = 0;
32925 Py_XINCREF((PyObject *) result);
32926 return ((PyObject*) result);
32927 }
32928
32929 static void
32930 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
32931 swig_varlinkobject *v;
32932 swig_globalvar *gv;
32933 v= (swig_varlinkobject *) p;
32934 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
32935 gv->name = (char *) malloc(strlen(name)+1);
32936 strcpy(gv->name,name);
32937 gv->get_attr = get_attr;
32938 gv->set_attr = set_attr;
32939 gv->next = v->vars;
32940 v->vars = gv;
32941 }
32942
32943 /* -----------------------------------------------------------------------------
32944 * constants/methods manipulation
32945 * ----------------------------------------------------------------------------- */
32946
32947 /* Install Constants */
32948 static void
32949 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
32950 PyObject *obj = 0;
32951 size_t i;
32952 for (i = 0; constants[i].type; i++) {
32953 switch(constants[i].type) {
32954 case SWIG_PY_INT:
32955 obj = PyInt_FromLong(constants[i].lvalue);
32956 break;
32957 case SWIG_PY_FLOAT:
32958 obj = PyFloat_FromDouble(constants[i].dvalue);
32959 break;
32960 case SWIG_PY_STRING:
32961 if (constants[i].pvalue) {
32962 obj = PyString_FromString((char *) constants[i].pvalue);
32963 } else {
32964 Py_INCREF(Py_None);
32965 obj = Py_None;
32966 }
32967 break;
32968 case SWIG_PY_POINTER:
32969 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
32970 break;
32971 case SWIG_PY_BINARY:
32972 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
32973 break;
32974 default:
32975 obj = 0;
32976 break;
32977 }
32978 if (obj) {
32979 PyDict_SetItemString(d,constants[i].name,obj);
32980 Py_DECREF(obj);
32981 }
32982 }
32983 }
32984
32985 /* -----------------------------------------------------------------------------*/
32986 /* Fix SwigMethods to carry the callback ptrs when needed */
32987 /* -----------------------------------------------------------------------------*/
32988
32989 static void
32990 SWIG_Python_FixMethods(PyMethodDef *methods,
32991 swig_const_info *const_table,
32992 swig_type_info **types,
32993 swig_type_info **types_initial) {
32994 size_t i;
32995 for (i = 0; methods[i].ml_name; ++i) {
32996 char *c = methods[i].ml_doc;
32997 if (c && (c = strstr(c, "swig_ptr: "))) {
32998 int j;
32999 swig_const_info *ci = 0;
33000 char *name = c + 10;
33001 for (j = 0; const_table[j].type; j++) {
33002 if (strncmp(const_table[j].name, name,
33003 strlen(const_table[j].name)) == 0) {
33004 ci = &(const_table[j]);
33005 break;
33006 }
33007 }
33008 if (ci) {
33009 size_t shift = (ci->ptype) - types;
33010 swig_type_info *ty = types_initial[shift];
33011 size_t ldoc = (c - methods[i].ml_doc);
33012 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33013 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33014 char *buff = ndoc;
33015 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33016 strncpy(buff, methods[i].ml_doc, ldoc);
33017 buff += ldoc;
33018 strncpy(buff, "swig_ptr: ", 10);
33019 buff += 10;
33020 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33021 methods[i].ml_doc = ndoc;
33022 }
33023 }
33024 }
33025 }
33026
33027 /* -----------------------------------------------------------------------------*
33028 * Initialize type list
33029 * -----------------------------------------------------------------------------*/
33030
33031 #if PY_MAJOR_VERSION < 2
33032 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33033 is copied out of Python/modsupport.c in python version 2.3.4 */
33034 static int
33035 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33036 {
33037 PyObject *dict;
33038 if (!PyModule_Check(m)) {
33039 PyErr_SetString(PyExc_TypeError,
33040 "PyModule_AddObject() needs module as first arg");
33041 return -1;
33042 }
33043 if (!o) {
33044 PyErr_SetString(PyExc_TypeError,
33045 "PyModule_AddObject() needs non-NULL value");
33046 return -1;
33047 }
33048
33049 dict = PyModule_GetDict(m);
33050 if (dict == NULL) {
33051 /* Internal error -- modules must have a dict! */
33052 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33053 PyModule_GetName(m));
33054 return -1;
33055 }
33056 if (PyDict_SetItemString(dict, name, o))
33057 return -1;
33058 Py_DECREF(o);
33059 return 0;
33060 }
33061 #endif
33062
33063 static swig_type_info **
33064 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33065 static PyMethodDef swig_empty_runtime_method_table[] = {
33066 {
33067 NULL, NULL, 0, NULL
33068 }
33069 };/* Sentinel */
33070
33071 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33072 swig_empty_runtime_method_table);
33073 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33074 if (pointer && module) {
33075 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33076 }
33077 return type_list_handle;
33078 }
33079
33080 static swig_type_info **
33081 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33082 swig_type_info **type_pointer;
33083
33084 /* first check if module already created */
33085 type_pointer = SWIG_Python_GetTypeListHandle();
33086 if (type_pointer) {
33087 return type_pointer;
33088 } else {
33089 /* create a new module and variable */
33090 return SWIG_Python_SetTypeListHandle(type_list_handle);
33091 }
33092 }
33093
33094 #ifdef __cplusplus
33095 }
33096 #endif
33097
33098 /* -----------------------------------------------------------------------------*
33099 * Partial Init method
33100 * -----------------------------------------------------------------------------*/
33101
33102 #ifdef SWIG_LINK_RUNTIME
33103 #ifdef __cplusplus
33104 extern "C"
33105 #endif
33106 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33107 #endif
33108
33109 #ifdef __cplusplus
33110 extern "C"
33111 #endif
33112 SWIGEXPORT(void) SWIG_init(void) {
33113 static PyObject *SWIG_globals = 0;
33114 static int typeinit = 0;
33115 PyObject *m, *d;
33116 int i;
33117 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33118
33119 /* Fix SwigMethods to carry the callback ptrs when needed */
33120 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33121
33122 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33123 d = PyModule_GetDict(m);
33124
33125 if (!typeinit) {
33126 #ifdef SWIG_LINK_RUNTIME
33127 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33128 #else
33129 # ifndef SWIG_STATIC_RUNTIME
33130 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33131 # endif
33132 #endif
33133 for (i = 0; swig_types_initial[i]; i++) {
33134 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33135 }
33136 typeinit = 1;
33137 }
33138 SWIG_InstallConstants(d,swig_const_table);
33139
33140 {
33141 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33142 }
33143 {
33144 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33145 }
33146 {
33147 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33148 }
33149 {
33150 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33151 }
33152 {
33153 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33154 }
33155 {
33156 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33157 }
33158 {
33159 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33160 }
33161 {
33162 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33163 }
33164 {
33165 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33166 }
33167 {
33168 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33169 }
33170 {
33171 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33172 }
33173 {
33174 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33175 }
33176 {
33177 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33178 }
33179 {
33180 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33181 }
33182 {
33183 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33184 }
33185 {
33186 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33187 }
33188 {
33189 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33190 }
33191 {
33192 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33193 }
33194 {
33195 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33196 }
33197 {
33198 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33199 }
33200 {
33201 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33202 }
33203 {
33204 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33205 }
33206 {
33207 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33208 }
33209 {
33210 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33211 }
33212 {
33213 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33214 }
33215 {
33216 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33217 }
33218 {
33219 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33220 }
33221 {
33222 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33412 }
33413 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33414 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33415 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33416 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33417 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33418 {
33419 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33420 }
33421 {
33422 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33423 }
33424 {
33425 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33426 }
33427 {
33428 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33429 }
33430 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33431
33432 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33433
33434 {
33435 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33466 }
33467 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33468 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33469 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33470 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33471 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33472 {
33473 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33474 }
33475 {
33476 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33477 }
33478 {
33479 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33480 }
33481 {
33482 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33483 }
33484 {
33485 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33486 }
33487 {
33488 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33489 }
33490 {
33491 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33492 }
33493 {
33494 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33495 }
33496 {
33497 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33498 }
33499 {
33500 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33510 }
33511 {
33512 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33513 }
33514 {
33515 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33516 }
33517 {
33518 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33519 }
33520 {
33521 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33522 }
33523 {
33524 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33525 }
33526 {
33527 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33528 }
33529 {
33530 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33540 }
33541 {
33542 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33543 }
33544 {
33545 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33546 }
33547 {
33548 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33549 }
33550 {
33551 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33552 }
33553 {
33554 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33564 }
33565 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33566 {
33567 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33577 }
33578 {
33579 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33580 }
33581
33582 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33583
33584 {
33585 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33586 }
33587 {
33588 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33589 }
33590 {
33591 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33592 }
33593 {
33594 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33595 }
33596 {
33597 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33598 }
33599 {
33600 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33601 }
33602 {
33603 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33604 }
33605 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33606 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33607 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33608 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33609 {
33610 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33611 }
33612 {
33613 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33614 }
33615 {
33616 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33617 }
33618 {
33619 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33620 }
33621 {
33622 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33623 }
33624 {
33625 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33626 }
33627 {
33628 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33629 }
33630 {
33631 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33632 }
33633 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33634 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33635 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33636 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33637 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33638 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33639 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33640 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33641 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33642 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33643 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33644 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33645 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33646 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33647 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33648 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33649 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33650 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33651 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33652 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33653 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33654 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33655 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33656 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33657 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33658 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33659 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33660 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33661 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33662 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33663 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33664 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33665 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33666 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33667 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33668 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33669 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33670 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33671 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33672 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33673 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33674 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33675 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33676 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33677 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33678 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33679 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33680 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33681 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33682 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33683 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33684 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33685 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33686 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33687 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33688 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33689
33690 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33691
33692 {
33693 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33694 }
33695 {
33696 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33715 }
33716 {
33717 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33718 }
33719 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33721 {
33722 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33723 }
33724 {
33725 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33726 }
33727 {
33728 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33729 }
33730 {
33731 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33732 }
33733 {
33734 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33735 }
33736 {
33737 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33738 }
33739 {
33740 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33741 }
33742 {
33743 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33744 }
33745 {
33746 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33747 }
33748 {
33749 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33750 }
33751 {
33752 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33753 }
33754 {
33755 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33756 }
33757 {
33758 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33759 }
33760 {
33761 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33762 }
33763 {
33764 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33765 }
33766 {
33767 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33768 }
33769 {
33770 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33771 }
33772 {
33773 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33774 }
33775 {
33776 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33777 }
33778 {
33779 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33780 }
33781 {
33782 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33783 }
33784 {
33785 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33786 }
33787 {
33788 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33789 }
33790 {
33791 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33792 }
33793 {
33794 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33795 }
33796 {
33797 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33798 }
33799 {
33800 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33801 }
33802 {
33803 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34185 }
34186 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34187 {
34188 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34189 }
34190 {
34191 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34192 }
34193 {
34194 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34195 }
34196 {
34197 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34198 }
34199 {
34200 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34201 }
34202 {
34203 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34204 }
34205 {
34206 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34207 }
34208 {
34209 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34210 }
34211 {
34212 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34213 }
34214 {
34215 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34216 }
34217 {
34218 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34219 }
34220 {
34221 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34222 }
34223 {
34224 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34225 }
34226 {
34227 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34228 }
34229 {
34230 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34231 }
34232 {
34233 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34234 }
34235 {
34236 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34237 }
34238 {
34239 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34240 }
34241 {
34242 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34243 }
34244 {
34245 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34246 }
34247 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34248 {
34249 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34250 }
34251 {
34252 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34253 }
34254 {
34255 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34256 }
34257 {
34258 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34259 }
34260 {
34261 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34262 }
34263 {
34264 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34265 }
34266 {
34267 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34268 }
34269 {
34270 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34271 }
34272 {
34273 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34274 }
34275 {
34276 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34277 }
34278 {
34279 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34280 }
34281 {
34282 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34283 }
34284
34285 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34286 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34287 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34288 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34289
34290 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34291 }
34292
wxWidgets (Impactor)