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


143d7a2eef9f23cb30bbb5c829f170fa9b4fc9b4
[wxWidgets.git] / wxPython / src / mac / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 bool blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 bool blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 bool blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 bool blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 bool blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 bool blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 bool blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 bool blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260
2261
2262 // Make a tuple and put the values in it
2263 bool blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 bool blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 bool blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518
2519 #if UINT_MAX < LONG_MAX
2520 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2521 #define SWIG_From_unsigned_SS_int SWIG_From_long
2522 /*@@*/
2523 #else
2524 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2525 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2526 /*@@*/
2527 #endif
2528
2529 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2530 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2531 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2532 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2533 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2534 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2535 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2536 return (*self < *other);
2537 }
2538 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2539 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2540 return (*self <= *other);
2541 }
2542 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2543 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2544 return (*self > *other);
2545 }
2546 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2547 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2548 return (*self >= *other);
2549 }
2550 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2551 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2552 return (*self == *other);
2553 }
2554 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2555 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2556 return (*self != *other);
2557 }
2558 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2559 const wxChar* rv;
2560 const wxChar* _date = date;
2561 rv = self->ParseRfc822Date(_date);
2562 if (rv == NULL) return -1;
2563 return rv - _date;
2564 }
2565 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2566 const wxChar* rv;
2567 const wxChar* _date = date;
2568 rv = self->ParseFormat(_date, format, dateDef);
2569 if (rv == NULL) return -1;
2570 return rv - _date;
2571 }
2572 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2573 const wxChar* rv;
2574 const wxChar* _datetime = datetime;
2575 rv = self->ParseDateTime(_datetime);
2576 if (rv == NULL) return -1;
2577 return rv - _datetime;
2578 }
2579 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2580 const wxChar* rv;
2581 const wxChar* _date = date;
2582 rv = self->ParseDate(_date);
2583 if (rv == NULL) return -1;
2584 return rv - _date;
2585 }
2586 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2587 const wxChar* rv;
2588 const wxChar* _time = time;
2589 rv = self->ParseTime(_time);
2590 if (rv == NULL) return -1;
2591 return rv - _time;
2592 }
2593 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2594 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2595 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2596 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2597 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2598 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2599 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2600 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2601 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2602 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2603 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2604 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2605 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2606 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2607 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2608 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2609
2610 #include <wx/dataobj.h>
2611
2612 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2613 size_t count = self->GetFormatCount(dir);
2614 wxDataFormat* formats = new wxDataFormat[count];
2615 self->GetAllFormats(formats, dir);
2616
2617 bool blocked = wxPyBeginBlockThreads();
2618 PyObject* list = PyList_New(count);
2619 for (size_t i=0; i<count; i++) {
2620 wxDataFormat* format = new wxDataFormat(formats[i]);
2621 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2622 PyList_Append(list, obj);
2623 Py_DECREF(obj);
2624 }
2625 wxPyEndBlockThreads(blocked);
2626 delete [] formats;
2627 return list;
2628 }
2629 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2630 PyObject* rval = NULL;
2631 size_t size = self->GetDataSize(format);
2632 bool blocked = wxPyBeginBlockThreads();
2633 if (size) {
2634 char* buf = new char[size];
2635 if (self->GetDataHere(format, buf))
2636 rval = PyString_FromStringAndSize(buf, size);
2637 delete [] buf;
2638 }
2639 if (! rval) {
2640 rval = Py_None;
2641 Py_INCREF(rval);
2642 }
2643 wxPyEndBlockThreads(blocked);
2644 return rval;
2645 }
2646 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2647 bool rval;
2648 bool blocked = wxPyBeginBlockThreads();
2649 if (PyString_Check(data)) {
2650 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2651 }
2652 else {
2653 // raise a TypeError if not a string
2654 PyErr_SetString(PyExc_TypeError, "String expected.");
2655 rval = false;
2656 }
2657 wxPyEndBlockThreads(blocked);
2658 return rval;
2659 }
2660 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2661 PyObject* rval = NULL;
2662 size_t size = self->GetDataSize();
2663 bool blocked = wxPyBeginBlockThreads();
2664 if (size) {
2665 char* buf = new char[size];
2666 if (self->GetDataHere(buf))
2667 rval = PyString_FromStringAndSize(buf, size);
2668 delete [] buf;
2669 }
2670 if (! rval) {
2671 rval = Py_None;
2672 Py_INCREF(rval);
2673 }
2674 wxPyEndBlockThreads(blocked);
2675 return rval;
2676 }
2677 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2678 bool rval;
2679 bool blocked = wxPyBeginBlockThreads();
2680 if (PyString_Check(data)) {
2681 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2682 }
2683 else {
2684 // raise a TypeError if not a string
2685 PyErr_SetString(PyExc_TypeError, "String expected.");
2686 rval = false;
2687 }
2688 wxPyEndBlockThreads(blocked);
2689 return rval;
2690 }
2691 // Create a new class for wxPython to use
2692 class wxPyDataObjectSimple : public wxDataObjectSimple {
2693 public:
2694 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2695 : wxDataObjectSimple(format) {}
2696
2697 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2698 bool GetDataHere(void *buf) const;
2699 bool SetData(size_t len, const void *buf) const;
2700 PYPRIVATE;
2701 };
2702
2703 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2704
2705 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2706 // We need to get the data for this object and write it to buf. I think
2707 // the best way to do this for wxPython is to have the Python method
2708 // return either a string or None and then act appropriately with the
2709 // C++ version.
2710
2711 bool rval = false;
2712 bool blocked = wxPyBeginBlockThreads();
2713 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2714 PyObject* ro;
2715 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2716 if (ro) {
2717 rval = (ro != Py_None && PyString_Check(ro));
2718 if (rval)
2719 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2720 Py_DECREF(ro);
2721 }
2722 }
2723 wxPyEndBlockThreads(blocked);
2724 return rval;
2725 }
2726
2727 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2728 // For this one we simply need to make a string from buf and len
2729 // and send it to the Python method.
2730 bool rval = false;
2731 bool blocked = wxPyBeginBlockThreads();
2732 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2733 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2734 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2735 Py_DECREF(data);
2736 }
2737 wxPyEndBlockThreads(blocked);
2738 return rval;
2739 }
2740
2741 // Create a new class for wxPython to use
2742 class wxPyTextDataObject : public wxTextDataObject {
2743 public:
2744 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2745 : wxTextDataObject(text) {}
2746
2747 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2748 DEC_PYCALLBACK_STRING__const(GetText);
2749 DEC_PYCALLBACK__STRING(SetText);
2750 PYPRIVATE;
2751 };
2752
2753 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2754 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2755 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2756
2757
2758 // Create a new class for wxPython to use
2759 class wxPyBitmapDataObject : public wxBitmapDataObject {
2760 public:
2761 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2762 : wxBitmapDataObject(bitmap) {}
2763
2764 wxBitmap GetBitmap() const;
2765 void SetBitmap(const wxBitmap& bitmap);
2766 PYPRIVATE;
2767 };
2768
2769 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2770 wxBitmap* rval = &wxNullBitmap;
2771 bool blocked = wxPyBeginBlockThreads();
2772 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2773 PyObject* ro;
2774 wxBitmap* ptr;
2775 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2776 if (ro) {
2777 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2778 rval = ptr;
2779 Py_DECREF(ro);
2780 }
2781 }
2782 wxPyEndBlockThreads(blocked);
2783 return *rval;
2784 }
2785
2786 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2787 bool blocked = wxPyBeginBlockThreads();
2788 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2789 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2790 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2791 Py_DECREF(bo);
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 }
2795
2796 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2797 return new wxCustomDataObject(wxDataFormat(formatName));
2798 }
2799 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2800 bool rval;
2801 bool blocked = wxPyBeginBlockThreads();
2802 if (PyString_Check(data)) {
2803 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2804 }
2805 else {
2806 // raise a TypeError if not a string
2807 PyErr_SetString(PyExc_TypeError, "String expected.");
2808 rval = false;
2809 }
2810 wxPyEndBlockThreads(blocked);
2811 return rval;
2812 }
2813 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2814 PyObject* obj;
2815 bool blocked = wxPyBeginBlockThreads();
2816 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2817 wxPyEndBlockThreads(blocked);
2818 return obj;
2819 }
2820
2821 #include <wx/metafile.h>
2822
2823
2824 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2825
2826
2827 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2828 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2829 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2830 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2831 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2832
2833
2834 class wxPyTextDropTarget : public wxTextDropTarget {
2835 public:
2836 wxPyTextDropTarget() {}
2837
2838 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2839
2840 DEC_PYCALLBACK__(OnLeave);
2841 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2842 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2843 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2844 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2845
2846 PYPRIVATE;
2847 };
2848
2849 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2850 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2851 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2852 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2853 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2854 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2855
2856
2857
2858 class wxPyFileDropTarget : public wxFileDropTarget {
2859 public:
2860 wxPyFileDropTarget() {}
2861
2862 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2863
2864 DEC_PYCALLBACK__(OnLeave);
2865 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2866 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2867 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2868 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2869
2870 PYPRIVATE;
2871 };
2872
2873 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2874 const wxArrayString& filenames) {
2875 bool rval = false;
2876 bool blocked = wxPyBeginBlockThreads();
2877 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2878 PyObject* list = wxArrayString2PyList_helper(filenames);
2879 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2880 Py_DECREF(list);
2881 }
2882 wxPyEndBlockThreads(blocked);
2883 return rval;
2884 }
2885
2886
2887
2888 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2889 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2890 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2891 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2892 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2893
2894
2895
2896
2897 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2898
2899 #include <wx/display.h>
2900
2901 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2902 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2903
2904 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2905 #if !wxUSE_DISPLAY
2906 #include <wx/dynarray.h>
2907 #include <wx/vidmode.h>
2908
2909 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2910 #include "wx/arrimpl.cpp"
2911 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2912 const wxVideoMode wxDefaultVideoMode;
2913
2914 class wxDisplay
2915 {
2916 public:
2917 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2918 ~wxDisplay() {}
2919
2920 static size_t GetCount()
2921 { wxPyRaiseNotImplemented(); return 0; }
2922
2923 static int GetFromPoint(const wxPoint& pt)
2924 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2925 static int GetFromWindow(wxWindow *window)
2926 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2927
2928 virtual bool IsOk() const { return false; }
2929 virtual wxRect GetGeometry() const { wxRect r; return r; }
2930 virtual wxString GetName() const { return wxEmptyString; }
2931 bool IsPrimary() const { return false; }
2932
2933 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2934 { wxArrayVideoModes a; return a; }
2935
2936 virtual wxVideoMode GetCurrentMode() const
2937 { return wxDefaultVideoMode; }
2938
2939 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2940 { return false; }
2941
2942 void ResetMode() {}
2943 };
2944 #endif
2945
2946 static int Display_GetFromWindow(wxWindow *window){ wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2947 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2948 PyObject* pyList = NULL;
2949 wxArrayVideoModes arr = self->GetModes(mode);
2950 bool blocked = wxPyBeginBlockThreads();
2951 pyList = PyList_New(0);
2952 for (int i=0; i < arr.GetCount(); i++) {
2953 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2954 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2955 PyList_Append(pyList, pyObj);
2956 Py_DECREF(pyObj);
2957 }
2958 wxPyEndBlockThreads(blocked);
2959 return pyList;
2960 }
2961
2962 #include <wx/stdpaths.h>
2963
2964 static wxStandardPaths *StandardPaths_Get(){
2965 return (wxStandardPaths*) &wxStandardPaths::Get();
2966 }
2967 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2968 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2969 #ifdef __cplusplus
2970 extern "C" {
2971 #endif
2972 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2973 PyObject *resultobj;
2974 wxSystemColour arg1 ;
2975 wxColour result;
2976 PyObject * obj0 = 0 ;
2977 char *kwnames[] = {
2978 (char *) "index", NULL
2979 };
2980
2981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2982 {
2983 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2984 if (SWIG_arg_fail(1)) SWIG_fail;
2985 }
2986 {
2987 if (!wxPyCheckForApp()) SWIG_fail;
2988 PyThreadState* __tstate = wxPyBeginAllowThreads();
2989 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
2990
2991 wxPyEndAllowThreads(__tstate);
2992 if (PyErr_Occurred()) SWIG_fail;
2993 }
2994 {
2995 wxColour * resultptr;
2996 resultptr = new wxColour((wxColour &)(result));
2997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
2998 }
2999 return resultobj;
3000 fail:
3001 return NULL;
3002 }
3003
3004
3005 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3006 PyObject *resultobj;
3007 wxSystemFont arg1 ;
3008 wxFont result;
3009 PyObject * obj0 = 0 ;
3010 char *kwnames[] = {
3011 (char *) "index", NULL
3012 };
3013
3014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3015 {
3016 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3017 if (SWIG_arg_fail(1)) SWIG_fail;
3018 }
3019 {
3020 if (!wxPyCheckForApp()) SWIG_fail;
3021 PyThreadState* __tstate = wxPyBeginAllowThreads();
3022 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3023
3024 wxPyEndAllowThreads(__tstate);
3025 if (PyErr_Occurred()) SWIG_fail;
3026 }
3027 {
3028 wxFont * resultptr;
3029 resultptr = new wxFont((wxFont &)(result));
3030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3031 }
3032 return resultobj;
3033 fail:
3034 return NULL;
3035 }
3036
3037
3038 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3039 PyObject *resultobj;
3040 wxSystemMetric arg1 ;
3041 int result;
3042 PyObject * obj0 = 0 ;
3043 char *kwnames[] = {
3044 (char *) "index", NULL
3045 };
3046
3047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3048 {
3049 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3050 if (SWIG_arg_fail(1)) SWIG_fail;
3051 }
3052 {
3053 if (!wxPyCheckForApp()) SWIG_fail;
3054 PyThreadState* __tstate = wxPyBeginAllowThreads();
3055 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3056
3057 wxPyEndAllowThreads(__tstate);
3058 if (PyErr_Occurred()) SWIG_fail;
3059 }
3060 {
3061 resultobj = SWIG_From_int((int)(result));
3062 }
3063 return resultobj;
3064 fail:
3065 return NULL;
3066 }
3067
3068
3069 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3070 PyObject *resultobj;
3071 wxSystemFeature arg1 ;
3072 bool result;
3073 PyObject * obj0 = 0 ;
3074 char *kwnames[] = {
3075 (char *) "index", NULL
3076 };
3077
3078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3079 {
3080 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3081 if (SWIG_arg_fail(1)) SWIG_fail;
3082 }
3083 {
3084 if (!wxPyCheckForApp()) SWIG_fail;
3085 PyThreadState* __tstate = wxPyBeginAllowThreads();
3086 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3087
3088 wxPyEndAllowThreads(__tstate);
3089 if (PyErr_Occurred()) SWIG_fail;
3090 }
3091 {
3092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3093 }
3094 return resultobj;
3095 fail:
3096 return NULL;
3097 }
3098
3099
3100 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3101 PyObject *resultobj;
3102 wxSystemScreenType result;
3103 char *kwnames[] = {
3104 NULL
3105 };
3106
3107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3108 {
3109 if (!wxPyCheckForApp()) SWIG_fail;
3110 PyThreadState* __tstate = wxPyBeginAllowThreads();
3111 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3112
3113 wxPyEndAllowThreads(__tstate);
3114 if (PyErr_Occurred()) SWIG_fail;
3115 }
3116 resultobj = SWIG_From_int((result));
3117 return resultobj;
3118 fail:
3119 return NULL;
3120 }
3121
3122
3123 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3124 PyObject *resultobj;
3125 wxSystemScreenType arg1 ;
3126 PyObject * obj0 = 0 ;
3127 char *kwnames[] = {
3128 (char *) "screen", NULL
3129 };
3130
3131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3132 {
3133 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3134 if (SWIG_arg_fail(1)) SWIG_fail;
3135 }
3136 {
3137 if (!wxPyCheckForApp()) SWIG_fail;
3138 PyThreadState* __tstate = wxPyBeginAllowThreads();
3139 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3140
3141 wxPyEndAllowThreads(__tstate);
3142 if (PyErr_Occurred()) SWIG_fail;
3143 }
3144 Py_INCREF(Py_None); resultobj = Py_None;
3145 return resultobj;
3146 fail:
3147 return NULL;
3148 }
3149
3150
3151 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3152 PyObject *obj;
3153 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3154 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3155 Py_INCREF(obj);
3156 return Py_BuildValue((char *)"");
3157 }
3158 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3159 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3160 return 1;
3161 }
3162
3163
3164 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3165 PyObject *pyobj;
3166
3167 {
3168 #if wxUSE_UNICODE
3169 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3170 #else
3171 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3172 #endif
3173 }
3174 return pyobj;
3175 }
3176
3177
3178 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3179 PyObject *resultobj;
3180 wxSystemOptions *result;
3181 char *kwnames[] = {
3182 NULL
3183 };
3184
3185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3186 {
3187 PyThreadState* __tstate = wxPyBeginAllowThreads();
3188 result = (wxSystemOptions *)new wxSystemOptions();
3189
3190 wxPyEndAllowThreads(__tstate);
3191 if (PyErr_Occurred()) SWIG_fail;
3192 }
3193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3194 return resultobj;
3195 fail:
3196 return NULL;
3197 }
3198
3199
3200 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3201 PyObject *resultobj;
3202 wxString *arg1 = 0 ;
3203 wxString *arg2 = 0 ;
3204 bool temp1 = false ;
3205 bool temp2 = false ;
3206 PyObject * obj0 = 0 ;
3207 PyObject * obj1 = 0 ;
3208 char *kwnames[] = {
3209 (char *) "name",(char *) "value", NULL
3210 };
3211
3212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3213 {
3214 arg1 = wxString_in_helper(obj0);
3215 if (arg1 == NULL) SWIG_fail;
3216 temp1 = true;
3217 }
3218 {
3219 arg2 = wxString_in_helper(obj1);
3220 if (arg2 == NULL) SWIG_fail;
3221 temp2 = true;
3222 }
3223 {
3224 PyThreadState* __tstate = wxPyBeginAllowThreads();
3225 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3226
3227 wxPyEndAllowThreads(__tstate);
3228 if (PyErr_Occurred()) SWIG_fail;
3229 }
3230 Py_INCREF(Py_None); resultobj = Py_None;
3231 {
3232 if (temp1)
3233 delete arg1;
3234 }
3235 {
3236 if (temp2)
3237 delete arg2;
3238 }
3239 return resultobj;
3240 fail:
3241 {
3242 if (temp1)
3243 delete arg1;
3244 }
3245 {
3246 if (temp2)
3247 delete arg2;
3248 }
3249 return NULL;
3250 }
3251
3252
3253 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3254 PyObject *resultobj;
3255 wxString *arg1 = 0 ;
3256 int arg2 ;
3257 bool temp1 = false ;
3258 PyObject * obj0 = 0 ;
3259 PyObject * obj1 = 0 ;
3260 char *kwnames[] = {
3261 (char *) "name",(char *) "value", NULL
3262 };
3263
3264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3265 {
3266 arg1 = wxString_in_helper(obj0);
3267 if (arg1 == NULL) SWIG_fail;
3268 temp1 = true;
3269 }
3270 {
3271 arg2 = (int)(SWIG_As_int(obj1));
3272 if (SWIG_arg_fail(2)) SWIG_fail;
3273 }
3274 {
3275 PyThreadState* __tstate = wxPyBeginAllowThreads();
3276 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3277
3278 wxPyEndAllowThreads(__tstate);
3279 if (PyErr_Occurred()) SWIG_fail;
3280 }
3281 Py_INCREF(Py_None); resultobj = Py_None;
3282 {
3283 if (temp1)
3284 delete arg1;
3285 }
3286 return resultobj;
3287 fail:
3288 {
3289 if (temp1)
3290 delete arg1;
3291 }
3292 return NULL;
3293 }
3294
3295
3296 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3297 PyObject *resultobj;
3298 wxString *arg1 = 0 ;
3299 wxString result;
3300 bool temp1 = false ;
3301 PyObject * obj0 = 0 ;
3302 char *kwnames[] = {
3303 (char *) "name", NULL
3304 };
3305
3306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3307 {
3308 arg1 = wxString_in_helper(obj0);
3309 if (arg1 == NULL) SWIG_fail;
3310 temp1 = true;
3311 }
3312 {
3313 PyThreadState* __tstate = wxPyBeginAllowThreads();
3314 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3315
3316 wxPyEndAllowThreads(__tstate);
3317 if (PyErr_Occurred()) SWIG_fail;
3318 }
3319 {
3320 #if wxUSE_UNICODE
3321 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3322 #else
3323 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3324 #endif
3325 }
3326 {
3327 if (temp1)
3328 delete arg1;
3329 }
3330 return resultobj;
3331 fail:
3332 {
3333 if (temp1)
3334 delete arg1;
3335 }
3336 return NULL;
3337 }
3338
3339
3340 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3341 PyObject *resultobj;
3342 wxString *arg1 = 0 ;
3343 int result;
3344 bool temp1 = false ;
3345 PyObject * obj0 = 0 ;
3346 char *kwnames[] = {
3347 (char *) "name", NULL
3348 };
3349
3350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3351 {
3352 arg1 = wxString_in_helper(obj0);
3353 if (arg1 == NULL) SWIG_fail;
3354 temp1 = true;
3355 }
3356 {
3357 PyThreadState* __tstate = wxPyBeginAllowThreads();
3358 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3359
3360 wxPyEndAllowThreads(__tstate);
3361 if (PyErr_Occurred()) SWIG_fail;
3362 }
3363 {
3364 resultobj = SWIG_From_int((int)(result));
3365 }
3366 {
3367 if (temp1)
3368 delete arg1;
3369 }
3370 return resultobj;
3371 fail:
3372 {
3373 if (temp1)
3374 delete arg1;
3375 }
3376 return NULL;
3377 }
3378
3379
3380 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3381 PyObject *resultobj;
3382 wxString *arg1 = 0 ;
3383 bool result;
3384 bool temp1 = false ;
3385 PyObject * obj0 = 0 ;
3386 char *kwnames[] = {
3387 (char *) "name", NULL
3388 };
3389
3390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3391 {
3392 arg1 = wxString_in_helper(obj0);
3393 if (arg1 == NULL) SWIG_fail;
3394 temp1 = true;
3395 }
3396 {
3397 PyThreadState* __tstate = wxPyBeginAllowThreads();
3398 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3399
3400 wxPyEndAllowThreads(__tstate);
3401 if (PyErr_Occurred()) SWIG_fail;
3402 }
3403 {
3404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3405 }
3406 {
3407 if (temp1)
3408 delete arg1;
3409 }
3410 return resultobj;
3411 fail:
3412 {
3413 if (temp1)
3414 delete arg1;
3415 }
3416 return NULL;
3417 }
3418
3419
3420 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3421 PyObject *obj;
3422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3423 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3424 Py_INCREF(obj);
3425 return Py_BuildValue((char *)"");
3426 }
3427 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3428 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3429 return 1;
3430 }
3431
3432
3433 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3434 PyObject *pyobj;
3435
3436 {
3437 #if wxUSE_UNICODE
3438 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3439 #else
3440 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3441 #endif
3442 }
3443 return pyobj;
3444 }
3445
3446
3447 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3448 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3449 return 1;
3450 }
3451
3452
3453 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3454 PyObject *pyobj;
3455
3456 {
3457 #if wxUSE_UNICODE
3458 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3459 #else
3460 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3461 #endif
3462 }
3463 return pyobj;
3464 }
3465
3466
3467 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3468 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3469 return 1;
3470 }
3471
3472
3473 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3474 PyObject *pyobj;
3475
3476 {
3477 #if wxUSE_UNICODE
3478 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3479 #else
3480 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3481 #endif
3482 }
3483 return pyobj;
3484 }
3485
3486
3487 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3488 PyObject *resultobj;
3489 long result;
3490 char *kwnames[] = {
3491 NULL
3492 };
3493
3494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3495 {
3496 PyThreadState* __tstate = wxPyBeginAllowThreads();
3497 result = (long)wxNewId();
3498
3499 wxPyEndAllowThreads(__tstate);
3500 if (PyErr_Occurred()) SWIG_fail;
3501 }
3502 {
3503 resultobj = SWIG_From_long((long)(result));
3504 }
3505 return resultobj;
3506 fail:
3507 return NULL;
3508 }
3509
3510
3511 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3512 PyObject *resultobj;
3513 long arg1 ;
3514 PyObject * obj0 = 0 ;
3515 char *kwnames[] = {
3516 (char *) "id", NULL
3517 };
3518
3519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3520 {
3521 arg1 = (long)(SWIG_As_long(obj0));
3522 if (SWIG_arg_fail(1)) SWIG_fail;
3523 }
3524 {
3525 PyThreadState* __tstate = wxPyBeginAllowThreads();
3526 wxRegisterId(arg1);
3527
3528 wxPyEndAllowThreads(__tstate);
3529 if (PyErr_Occurred()) SWIG_fail;
3530 }
3531 Py_INCREF(Py_None); resultobj = Py_None;
3532 return resultobj;
3533 fail:
3534 return NULL;
3535 }
3536
3537
3538 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3539 PyObject *resultobj;
3540 long result;
3541 char *kwnames[] = {
3542 NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3546 {
3547 PyThreadState* __tstate = wxPyBeginAllowThreads();
3548 result = (long)wxGetCurrentId();
3549
3550 wxPyEndAllowThreads(__tstate);
3551 if (PyErr_Occurred()) SWIG_fail;
3552 }
3553 {
3554 resultobj = SWIG_From_long((long)(result));
3555 }
3556 return resultobj;
3557 fail:
3558 return NULL;
3559 }
3560
3561
3562 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3563 PyObject *resultobj;
3564 int arg1 ;
3565 bool result;
3566 PyObject * obj0 = 0 ;
3567 char *kwnames[] = {
3568 (char *) "id", NULL
3569 };
3570
3571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3572 {
3573 arg1 = (int)(SWIG_As_int(obj0));
3574 if (SWIG_arg_fail(1)) SWIG_fail;
3575 }
3576 {
3577 PyThreadState* __tstate = wxPyBeginAllowThreads();
3578 result = (bool)wxIsStockID(arg1);
3579
3580 wxPyEndAllowThreads(__tstate);
3581 if (PyErr_Occurred()) SWIG_fail;
3582 }
3583 {
3584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3585 }
3586 return resultobj;
3587 fail:
3588 return NULL;
3589 }
3590
3591
3592 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3593 PyObject *resultobj;
3594 int arg1 ;
3595 wxString *arg2 = 0 ;
3596 bool result;
3597 bool temp2 = false ;
3598 PyObject * obj0 = 0 ;
3599 PyObject * obj1 = 0 ;
3600 char *kwnames[] = {
3601 (char *) "id",(char *) "label", NULL
3602 };
3603
3604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3605 {
3606 arg1 = (int)(SWIG_As_int(obj0));
3607 if (SWIG_arg_fail(1)) SWIG_fail;
3608 }
3609 {
3610 arg2 = wxString_in_helper(obj1);
3611 if (arg2 == NULL) SWIG_fail;
3612 temp2 = true;
3613 }
3614 {
3615 PyThreadState* __tstate = wxPyBeginAllowThreads();
3616 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3617
3618 wxPyEndAllowThreads(__tstate);
3619 if (PyErr_Occurred()) SWIG_fail;
3620 }
3621 {
3622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3623 }
3624 {
3625 if (temp2)
3626 delete arg2;
3627 }
3628 return resultobj;
3629 fail:
3630 {
3631 if (temp2)
3632 delete arg2;
3633 }
3634 return NULL;
3635 }
3636
3637
3638 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3639 PyObject *resultobj;
3640 int arg1 ;
3641 bool arg2 = (bool) true ;
3642 wxString arg3 = (wxString) wxPyEmptyString ;
3643 wxString result;
3644 PyObject * obj0 = 0 ;
3645 PyObject * obj1 = 0 ;
3646 PyObject * obj2 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3652 {
3653 arg1 = (int)(SWIG_As_int(obj0));
3654 if (SWIG_arg_fail(1)) SWIG_fail;
3655 }
3656 if (obj1) {
3657 {
3658 arg2 = (bool)(SWIG_As_bool(obj1));
3659 if (SWIG_arg_fail(2)) SWIG_fail;
3660 }
3661 }
3662 if (obj2) {
3663 {
3664 wxString* sptr = wxString_in_helper(obj2);
3665 if (sptr == NULL) SWIG_fail;
3666 arg3 = *sptr;
3667 delete sptr;
3668 }
3669 }
3670 {
3671 PyThreadState* __tstate = wxPyBeginAllowThreads();
3672 result = wxGetStockLabel(arg1,arg2,arg3);
3673
3674 wxPyEndAllowThreads(__tstate);
3675 if (PyErr_Occurred()) SWIG_fail;
3676 }
3677 {
3678 #if wxUSE_UNICODE
3679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3680 #else
3681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3682 #endif
3683 }
3684 return resultobj;
3685 fail:
3686 return NULL;
3687 }
3688
3689
3690 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3691 PyObject *resultobj;
3692 char *kwnames[] = {
3693 NULL
3694 };
3695
3696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3697 {
3698 if (!wxPyCheckForApp()) SWIG_fail;
3699 PyThreadState* __tstate = wxPyBeginAllowThreads();
3700 wxBell();
3701
3702 wxPyEndAllowThreads(__tstate);
3703 if (PyErr_Occurred()) SWIG_fail;
3704 }
3705 Py_INCREF(Py_None); resultobj = Py_None;
3706 return resultobj;
3707 fail:
3708 return NULL;
3709 }
3710
3711
3712 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3713 PyObject *resultobj;
3714 char *kwnames[] = {
3715 NULL
3716 };
3717
3718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3719 {
3720 if (!wxPyCheckForApp()) SWIG_fail;
3721 PyThreadState* __tstate = wxPyBeginAllowThreads();
3722 wxEndBusyCursor();
3723
3724 wxPyEndAllowThreads(__tstate);
3725 if (PyErr_Occurred()) SWIG_fail;
3726 }
3727 Py_INCREF(Py_None); resultobj = Py_None;
3728 return resultobj;
3729 fail:
3730 return NULL;
3731 }
3732
3733
3734 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3735 PyObject *resultobj;
3736 bool arg1 = (bool) true ;
3737 long result;
3738 PyObject * obj0 = 0 ;
3739 char *kwnames[] = {
3740 (char *) "resetTimer", NULL
3741 };
3742
3743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3744 if (obj0) {
3745 {
3746 arg1 = (bool)(SWIG_As_bool(obj0));
3747 if (SWIG_arg_fail(1)) SWIG_fail;
3748 }
3749 }
3750 {
3751 PyThreadState* __tstate = wxPyBeginAllowThreads();
3752 result = (long)wxGetElapsedTime(arg1);
3753
3754 wxPyEndAllowThreads(__tstate);
3755 if (PyErr_Occurred()) SWIG_fail;
3756 }
3757 {
3758 resultobj = SWIG_From_long((long)(result));
3759 }
3760 return resultobj;
3761 fail:
3762 return NULL;
3763 }
3764
3765
3766 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3767 PyObject *resultobj;
3768 int *arg1 = (int *) 0 ;
3769 int *arg2 = (int *) 0 ;
3770 int temp1 ;
3771 int res1 = 0 ;
3772 int temp2 ;
3773 int res2 = 0 ;
3774 char *kwnames[] = {
3775 NULL
3776 };
3777
3778 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3781 {
3782 if (!wxPyCheckForApp()) SWIG_fail;
3783 PyThreadState* __tstate = wxPyBeginAllowThreads();
3784 wxGetMousePosition(arg1,arg2);
3785
3786 wxPyEndAllowThreads(__tstate);
3787 if (PyErr_Occurred()) SWIG_fail;
3788 }
3789 Py_INCREF(Py_None); resultobj = Py_None;
3790 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3791 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3792 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3793 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3794 return resultobj;
3795 fail:
3796 return NULL;
3797 }
3798
3799
3800 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3801 PyObject *resultobj;
3802 bool result;
3803 char *kwnames[] = {
3804 NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3808 {
3809 PyThreadState* __tstate = wxPyBeginAllowThreads();
3810 result = (bool)wxIsBusy();
3811
3812 wxPyEndAllowThreads(__tstate);
3813 if (PyErr_Occurred()) SWIG_fail;
3814 }
3815 {
3816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3817 }
3818 return resultobj;
3819 fail:
3820 return NULL;
3821 }
3822
3823
3824 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3825 PyObject *resultobj;
3826 wxString result;
3827 char *kwnames[] = {
3828 NULL
3829 };
3830
3831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3832 {
3833 PyThreadState* __tstate = wxPyBeginAllowThreads();
3834 result = wxNow();
3835
3836 wxPyEndAllowThreads(__tstate);
3837 if (PyErr_Occurred()) SWIG_fail;
3838 }
3839 {
3840 #if wxUSE_UNICODE
3841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3842 #else
3843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3844 #endif
3845 }
3846 return resultobj;
3847 fail:
3848 return NULL;
3849 }
3850
3851
3852 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3853 PyObject *resultobj;
3854 wxString const &arg1_defvalue = wxPyEmptyString ;
3855 wxString *arg1 = (wxString *) &arg1_defvalue ;
3856 bool result;
3857 bool temp1 = false ;
3858 PyObject * obj0 = 0 ;
3859 char *kwnames[] = {
3860 (char *) "command", NULL
3861 };
3862
3863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3864 if (obj0) {
3865 {
3866 arg1 = wxString_in_helper(obj0);
3867 if (arg1 == NULL) SWIG_fail;
3868 temp1 = true;
3869 }
3870 }
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (bool)wxShell((wxString const &)*arg1);
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3880 }
3881 {
3882 if (temp1)
3883 delete arg1;
3884 }
3885 return resultobj;
3886 fail:
3887 {
3888 if (temp1)
3889 delete arg1;
3890 }
3891 return NULL;
3892 }
3893
3894
3895 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3896 PyObject *resultobj;
3897 char *kwnames[] = {
3898 NULL
3899 };
3900
3901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3902 {
3903 PyThreadState* __tstate = wxPyBeginAllowThreads();
3904 wxStartTimer();
3905
3906 wxPyEndAllowThreads(__tstate);
3907 if (PyErr_Occurred()) SWIG_fail;
3908 }
3909 Py_INCREF(Py_None); resultobj = Py_None;
3910 return resultobj;
3911 fail:
3912 return NULL;
3913 }
3914
3915
3916 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3917 PyObject *resultobj;
3918 int *arg1 = (int *) 0 ;
3919 int *arg2 = (int *) 0 ;
3920 int result;
3921 int temp1 ;
3922 int res1 = 0 ;
3923 int temp2 ;
3924 int res2 = 0 ;
3925 char *kwnames[] = {
3926 NULL
3927 };
3928
3929 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3930 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3932 {
3933 PyThreadState* __tstate = wxPyBeginAllowThreads();
3934 result = (int)wxGetOsVersion(arg1,arg2);
3935
3936 wxPyEndAllowThreads(__tstate);
3937 if (PyErr_Occurred()) SWIG_fail;
3938 }
3939 {
3940 resultobj = SWIG_From_int((int)(result));
3941 }
3942 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3943 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3944 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3945 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3946 return resultobj;
3947 fail:
3948 return NULL;
3949 }
3950
3951
3952 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxString result;
3955 char *kwnames[] = {
3956 NULL
3957 };
3958
3959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3960 {
3961 PyThreadState* __tstate = wxPyBeginAllowThreads();
3962 result = wxGetOsDescription();
3963
3964 wxPyEndAllowThreads(__tstate);
3965 if (PyErr_Occurred()) SWIG_fail;
3966 }
3967 {
3968 #if wxUSE_UNICODE
3969 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3970 #else
3971 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3972 #endif
3973 }
3974 return resultobj;
3975 fail:
3976 return NULL;
3977 }
3978
3979
3980 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj;
3982 long result;
3983 char *kwnames[] = {
3984 NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3988 {
3989 PyThreadState* __tstate = wxPyBeginAllowThreads();
3990 result = (long)wxGetFreeMemory();
3991
3992 wxPyEndAllowThreads(__tstate);
3993 if (PyErr_Occurred()) SWIG_fail;
3994 }
3995 {
3996 resultobj = SWIG_From_long((long)(result));
3997 }
3998 return resultobj;
3999 fail:
4000 return NULL;
4001 }
4002
4003
4004 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4005 PyObject *resultobj;
4006 wxShutdownFlags arg1 ;
4007 bool result;
4008 PyObject * obj0 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "wFlags", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4014 {
4015 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4016 if (SWIG_arg_fail(1)) SWIG_fail;
4017 }
4018 {
4019 if (!wxPyCheckForApp()) SWIG_fail;
4020 PyThreadState* __tstate = wxPyBeginAllowThreads();
4021 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4022
4023 wxPyEndAllowThreads(__tstate);
4024 if (PyErr_Occurred()) SWIG_fail;
4025 }
4026 {
4027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4028 }
4029 return resultobj;
4030 fail:
4031 return NULL;
4032 }
4033
4034
4035 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4036 PyObject *resultobj;
4037 int arg1 ;
4038 PyObject * obj0 = 0 ;
4039 char *kwnames[] = {
4040 (char *) "secs", NULL
4041 };
4042
4043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4044 {
4045 arg1 = (int)(SWIG_As_int(obj0));
4046 if (SWIG_arg_fail(1)) SWIG_fail;
4047 }
4048 {
4049 PyThreadState* __tstate = wxPyBeginAllowThreads();
4050 wxSleep(arg1);
4051
4052 wxPyEndAllowThreads(__tstate);
4053 if (PyErr_Occurred()) SWIG_fail;
4054 }
4055 Py_INCREF(Py_None); resultobj = Py_None;
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj;
4064 unsigned long arg1 ;
4065 PyObject * obj0 = 0 ;
4066 char *kwnames[] = {
4067 (char *) "milliseconds", NULL
4068 };
4069
4070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4071 {
4072 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4073 if (SWIG_arg_fail(1)) SWIG_fail;
4074 }
4075 {
4076 PyThreadState* __tstate = wxPyBeginAllowThreads();
4077 wxMilliSleep(arg1);
4078
4079 wxPyEndAllowThreads(__tstate);
4080 if (PyErr_Occurred()) SWIG_fail;
4081 }
4082 Py_INCREF(Py_None); resultobj = Py_None;
4083 return resultobj;
4084 fail:
4085 return NULL;
4086 }
4087
4088
4089 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4090 PyObject *resultobj;
4091 unsigned long arg1 ;
4092 PyObject * obj0 = 0 ;
4093 char *kwnames[] = {
4094 (char *) "microseconds", NULL
4095 };
4096
4097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4098 {
4099 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4100 if (SWIG_arg_fail(1)) SWIG_fail;
4101 }
4102 {
4103 PyThreadState* __tstate = wxPyBeginAllowThreads();
4104 wxMicroSleep(arg1);
4105
4106 wxPyEndAllowThreads(__tstate);
4107 if (PyErr_Occurred()) SWIG_fail;
4108 }
4109 Py_INCREF(Py_None); resultobj = Py_None;
4110 return resultobj;
4111 fail:
4112 return NULL;
4113 }
4114
4115
4116 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4117 PyObject *resultobj;
4118 bool arg1 ;
4119 PyObject * obj0 = 0 ;
4120 char *kwnames[] = {
4121 (char *) "enable", NULL
4122 };
4123
4124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4125 {
4126 arg1 = (bool)(SWIG_As_bool(obj0));
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 }
4129 {
4130 PyThreadState* __tstate = wxPyBeginAllowThreads();
4131 wxEnableTopLevelWindows(arg1);
4132
4133 wxPyEndAllowThreads(__tstate);
4134 if (PyErr_Occurred()) SWIG_fail;
4135 }
4136 Py_INCREF(Py_None); resultobj = Py_None;
4137 return resultobj;
4138 fail:
4139 return NULL;
4140 }
4141
4142
4143 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4144 PyObject *resultobj;
4145 wxString *arg1 = 0 ;
4146 wxString result;
4147 bool temp1 = false ;
4148 PyObject * obj0 = 0 ;
4149 char *kwnames[] = {
4150 (char *) "in", NULL
4151 };
4152
4153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4154 {
4155 arg1 = wxString_in_helper(obj0);
4156 if (arg1 == NULL) SWIG_fail;
4157 temp1 = true;
4158 }
4159 {
4160 PyThreadState* __tstate = wxPyBeginAllowThreads();
4161 result = wxStripMenuCodes((wxString const &)*arg1);
4162
4163 wxPyEndAllowThreads(__tstate);
4164 if (PyErr_Occurred()) SWIG_fail;
4165 }
4166 {
4167 #if wxUSE_UNICODE
4168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4169 #else
4170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4171 #endif
4172 }
4173 {
4174 if (temp1)
4175 delete arg1;
4176 }
4177 return resultobj;
4178 fail:
4179 {
4180 if (temp1)
4181 delete arg1;
4182 }
4183 return NULL;
4184 }
4185
4186
4187 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4188 PyObject *resultobj;
4189 wxString result;
4190 char *kwnames[] = {
4191 NULL
4192 };
4193
4194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4195 {
4196 PyThreadState* __tstate = wxPyBeginAllowThreads();
4197 result = wxGetEmailAddress();
4198
4199 wxPyEndAllowThreads(__tstate);
4200 if (PyErr_Occurred()) SWIG_fail;
4201 }
4202 {
4203 #if wxUSE_UNICODE
4204 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4205 #else
4206 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4207 #endif
4208 }
4209 return resultobj;
4210 fail:
4211 return NULL;
4212 }
4213
4214
4215 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4216 PyObject *resultobj;
4217 wxString result;
4218 char *kwnames[] = {
4219 NULL
4220 };
4221
4222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4223 {
4224 PyThreadState* __tstate = wxPyBeginAllowThreads();
4225 result = wxGetHostName();
4226
4227 wxPyEndAllowThreads(__tstate);
4228 if (PyErr_Occurred()) SWIG_fail;
4229 }
4230 {
4231 #if wxUSE_UNICODE
4232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4233 #else
4234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4235 #endif
4236 }
4237 return resultobj;
4238 fail:
4239 return NULL;
4240 }
4241
4242
4243 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4244 PyObject *resultobj;
4245 wxString result;
4246 char *kwnames[] = {
4247 NULL
4248 };
4249
4250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4251 {
4252 PyThreadState* __tstate = wxPyBeginAllowThreads();
4253 result = wxGetFullHostName();
4254
4255 wxPyEndAllowThreads(__tstate);
4256 if (PyErr_Occurred()) SWIG_fail;
4257 }
4258 {
4259 #if wxUSE_UNICODE
4260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4261 #else
4262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4263 #endif
4264 }
4265 return resultobj;
4266 fail:
4267 return NULL;
4268 }
4269
4270
4271 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4272 PyObject *resultobj;
4273 wxString result;
4274 char *kwnames[] = {
4275 NULL
4276 };
4277
4278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4279 {
4280 PyThreadState* __tstate = wxPyBeginAllowThreads();
4281 result = wxGetUserId();
4282
4283 wxPyEndAllowThreads(__tstate);
4284 if (PyErr_Occurred()) SWIG_fail;
4285 }
4286 {
4287 #if wxUSE_UNICODE
4288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4289 #else
4290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4291 #endif
4292 }
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4300 PyObject *resultobj;
4301 wxString result;
4302 char *kwnames[] = {
4303 NULL
4304 };
4305
4306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4307 {
4308 PyThreadState* __tstate = wxPyBeginAllowThreads();
4309 result = wxGetUserName();
4310
4311 wxPyEndAllowThreads(__tstate);
4312 if (PyErr_Occurred()) SWIG_fail;
4313 }
4314 {
4315 #if wxUSE_UNICODE
4316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4317 #else
4318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4319 #endif
4320 }
4321 return resultobj;
4322 fail:
4323 return NULL;
4324 }
4325
4326
4327 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxString result;
4330 char *kwnames[] = {
4331 NULL
4332 };
4333
4334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4335 {
4336 PyThreadState* __tstate = wxPyBeginAllowThreads();
4337 result = wxGetHomeDir();
4338
4339 wxPyEndAllowThreads(__tstate);
4340 if (PyErr_Occurred()) SWIG_fail;
4341 }
4342 {
4343 #if wxUSE_UNICODE
4344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4345 #else
4346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4347 #endif
4348 }
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj;
4357 wxString const &arg1_defvalue = wxPyEmptyString ;
4358 wxString *arg1 = (wxString *) &arg1_defvalue ;
4359 wxString result;
4360 bool temp1 = false ;
4361 PyObject * obj0 = 0 ;
4362 char *kwnames[] = {
4363 (char *) "user", NULL
4364 };
4365
4366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4367 if (obj0) {
4368 {
4369 arg1 = wxString_in_helper(obj0);
4370 if (arg1 == NULL) SWIG_fail;
4371 temp1 = true;
4372 }
4373 }
4374 {
4375 PyThreadState* __tstate = wxPyBeginAllowThreads();
4376 result = wxGetUserHome((wxString const &)*arg1);
4377
4378 wxPyEndAllowThreads(__tstate);
4379 if (PyErr_Occurred()) SWIG_fail;
4380 }
4381 {
4382 #if wxUSE_UNICODE
4383 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4384 #else
4385 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4386 #endif
4387 }
4388 {
4389 if (temp1)
4390 delete arg1;
4391 }
4392 return resultobj;
4393 fail:
4394 {
4395 if (temp1)
4396 delete arg1;
4397 }
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 unsigned long result;
4405 char *kwnames[] = {
4406 NULL
4407 };
4408
4409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4410 {
4411 PyThreadState* __tstate = wxPyBeginAllowThreads();
4412 result = (unsigned long)wxGetProcessId();
4413
4414 wxPyEndAllowThreads(__tstate);
4415 if (PyErr_Occurred()) SWIG_fail;
4416 }
4417 {
4418 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4419 }
4420 return resultobj;
4421 fail:
4422 return NULL;
4423 }
4424
4425
4426 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4427 PyObject *resultobj;
4428 char *kwnames[] = {
4429 NULL
4430 };
4431
4432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4433 {
4434 PyThreadState* __tstate = wxPyBeginAllowThreads();
4435 wxTrap();
4436
4437 wxPyEndAllowThreads(__tstate);
4438 if (PyErr_Occurred()) SWIG_fail;
4439 }
4440 Py_INCREF(Py_None); resultobj = Py_None;
4441 return resultobj;
4442 fail:
4443 return NULL;
4444 }
4445
4446
4447 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4448 PyObject *resultobj;
4449 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4450 wxString *arg1 = (wxString *) &arg1_defvalue ;
4451 wxString const &arg2_defvalue = wxPyEmptyString ;
4452 wxString *arg2 = (wxString *) &arg2_defvalue ;
4453 wxString const &arg3_defvalue = wxPyEmptyString ;
4454 wxString *arg3 = (wxString *) &arg3_defvalue ;
4455 wxString const &arg4_defvalue = wxPyEmptyString ;
4456 wxString *arg4 = (wxString *) &arg4_defvalue ;
4457 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4458 wxString *arg5 = (wxString *) &arg5_defvalue ;
4459 int arg6 = (int) 0 ;
4460 wxWindow *arg7 = (wxWindow *) NULL ;
4461 int arg8 = (int) -1 ;
4462 int arg9 = (int) -1 ;
4463 wxString result;
4464 bool temp1 = false ;
4465 bool temp2 = false ;
4466 bool temp3 = false ;
4467 bool temp4 = false ;
4468 bool temp5 = false ;
4469 PyObject * obj0 = 0 ;
4470 PyObject * obj1 = 0 ;
4471 PyObject * obj2 = 0 ;
4472 PyObject * obj3 = 0 ;
4473 PyObject * obj4 = 0 ;
4474 PyObject * obj5 = 0 ;
4475 PyObject * obj6 = 0 ;
4476 PyObject * obj7 = 0 ;
4477 PyObject * obj8 = 0 ;
4478 char *kwnames[] = {
4479 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4480 };
4481
4482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4483 if (obj0) {
4484 {
4485 arg1 = wxString_in_helper(obj0);
4486 if (arg1 == NULL) SWIG_fail;
4487 temp1 = true;
4488 }
4489 }
4490 if (obj1) {
4491 {
4492 arg2 = wxString_in_helper(obj1);
4493 if (arg2 == NULL) SWIG_fail;
4494 temp2 = true;
4495 }
4496 }
4497 if (obj2) {
4498 {
4499 arg3 = wxString_in_helper(obj2);
4500 if (arg3 == NULL) SWIG_fail;
4501 temp3 = true;
4502 }
4503 }
4504 if (obj3) {
4505 {
4506 arg4 = wxString_in_helper(obj3);
4507 if (arg4 == NULL) SWIG_fail;
4508 temp4 = true;
4509 }
4510 }
4511 if (obj4) {
4512 {
4513 arg5 = wxString_in_helper(obj4);
4514 if (arg5 == NULL) SWIG_fail;
4515 temp5 = true;
4516 }
4517 }
4518 if (obj5) {
4519 {
4520 arg6 = (int)(SWIG_As_int(obj5));
4521 if (SWIG_arg_fail(6)) SWIG_fail;
4522 }
4523 }
4524 if (obj6) {
4525 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4526 if (SWIG_arg_fail(7)) SWIG_fail;
4527 }
4528 if (obj7) {
4529 {
4530 arg8 = (int)(SWIG_As_int(obj7));
4531 if (SWIG_arg_fail(8)) SWIG_fail;
4532 }
4533 }
4534 if (obj8) {
4535 {
4536 arg9 = (int)(SWIG_As_int(obj8));
4537 if (SWIG_arg_fail(9)) SWIG_fail;
4538 }
4539 }
4540 {
4541 if (!wxPyCheckForApp()) SWIG_fail;
4542 PyThreadState* __tstate = wxPyBeginAllowThreads();
4543 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4544
4545 wxPyEndAllowThreads(__tstate);
4546 if (PyErr_Occurred()) SWIG_fail;
4547 }
4548 {
4549 #if wxUSE_UNICODE
4550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4551 #else
4552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4553 #endif
4554 }
4555 {
4556 if (temp1)
4557 delete arg1;
4558 }
4559 {
4560 if (temp2)
4561 delete arg2;
4562 }
4563 {
4564 if (temp3)
4565 delete arg3;
4566 }
4567 {
4568 if (temp4)
4569 delete arg4;
4570 }
4571 {
4572 if (temp5)
4573 delete arg5;
4574 }
4575 return resultobj;
4576 fail:
4577 {
4578 if (temp1)
4579 delete arg1;
4580 }
4581 {
4582 if (temp2)
4583 delete arg2;
4584 }
4585 {
4586 if (temp3)
4587 delete arg3;
4588 }
4589 {
4590 if (temp4)
4591 delete arg4;
4592 }
4593 {
4594 if (temp5)
4595 delete arg5;
4596 }
4597 return NULL;
4598 }
4599
4600
4601 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4602 PyObject *resultobj;
4603 wxString *arg1 = 0 ;
4604 wxString *arg2 = 0 ;
4605 wxString const &arg3_defvalue = wxPyEmptyString ;
4606 wxString *arg3 = (wxString *) &arg3_defvalue ;
4607 wxWindow *arg4 = (wxWindow *) NULL ;
4608 wxString result;
4609 bool temp1 = false ;
4610 bool temp2 = false ;
4611 bool temp3 = false ;
4612 PyObject * obj0 = 0 ;
4613 PyObject * obj1 = 0 ;
4614 PyObject * obj2 = 0 ;
4615 PyObject * obj3 = 0 ;
4616 char *kwnames[] = {
4617 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4618 };
4619
4620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4621 {
4622 arg1 = wxString_in_helper(obj0);
4623 if (arg1 == NULL) SWIG_fail;
4624 temp1 = true;
4625 }
4626 {
4627 arg2 = wxString_in_helper(obj1);
4628 if (arg2 == NULL) SWIG_fail;
4629 temp2 = true;
4630 }
4631 if (obj2) {
4632 {
4633 arg3 = wxString_in_helper(obj2);
4634 if (arg3 == NULL) SWIG_fail;
4635 temp3 = true;
4636 }
4637 }
4638 if (obj3) {
4639 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4640 if (SWIG_arg_fail(4)) SWIG_fail;
4641 }
4642 {
4643 if (!wxPyCheckForApp()) SWIG_fail;
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 {
4651 #if wxUSE_UNICODE
4652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4653 #else
4654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4655 #endif
4656 }
4657 {
4658 if (temp1)
4659 delete arg1;
4660 }
4661 {
4662 if (temp2)
4663 delete arg2;
4664 }
4665 {
4666 if (temp3)
4667 delete arg3;
4668 }
4669 return resultobj;
4670 fail:
4671 {
4672 if (temp1)
4673 delete arg1;
4674 }
4675 {
4676 if (temp2)
4677 delete arg2;
4678 }
4679 {
4680 if (temp3)
4681 delete arg3;
4682 }
4683 return NULL;
4684 }
4685
4686
4687 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4688 PyObject *resultobj;
4689 wxString *arg1 = 0 ;
4690 wxString *arg2 = 0 ;
4691 wxString const &arg3_defvalue = wxPyEmptyString ;
4692 wxString *arg3 = (wxString *) &arg3_defvalue ;
4693 wxWindow *arg4 = (wxWindow *) NULL ;
4694 wxString result;
4695 bool temp1 = false ;
4696 bool temp2 = false ;
4697 bool temp3 = false ;
4698 PyObject * obj0 = 0 ;
4699 PyObject * obj1 = 0 ;
4700 PyObject * obj2 = 0 ;
4701 PyObject * obj3 = 0 ;
4702 char *kwnames[] = {
4703 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4704 };
4705
4706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4707 {
4708 arg1 = wxString_in_helper(obj0);
4709 if (arg1 == NULL) SWIG_fail;
4710 temp1 = true;
4711 }
4712 {
4713 arg2 = wxString_in_helper(obj1);
4714 if (arg2 == NULL) SWIG_fail;
4715 temp2 = true;
4716 }
4717 if (obj2) {
4718 {
4719 arg3 = wxString_in_helper(obj2);
4720 if (arg3 == NULL) SWIG_fail;
4721 temp3 = true;
4722 }
4723 }
4724 if (obj3) {
4725 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4726 if (SWIG_arg_fail(4)) SWIG_fail;
4727 }
4728 {
4729 if (!wxPyCheckForApp()) SWIG_fail;
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4732
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 {
4737 #if wxUSE_UNICODE
4738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4739 #else
4740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4741 #endif
4742 }
4743 {
4744 if (temp1)
4745 delete arg1;
4746 }
4747 {
4748 if (temp2)
4749 delete arg2;
4750 }
4751 {
4752 if (temp3)
4753 delete arg3;
4754 }
4755 return resultobj;
4756 fail:
4757 {
4758 if (temp1)
4759 delete arg1;
4760 }
4761 {
4762 if (temp2)
4763 delete arg2;
4764 }
4765 {
4766 if (temp3)
4767 delete arg3;
4768 }
4769 return NULL;
4770 }
4771
4772
4773 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4774 PyObject *resultobj;
4775 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4776 wxString *arg1 = (wxString *) &arg1_defvalue ;
4777 wxString const &arg2_defvalue = wxPyEmptyString ;
4778 wxString *arg2 = (wxString *) &arg2_defvalue ;
4779 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4780 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4781 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4782 wxWindow *arg5 = (wxWindow *) NULL ;
4783 wxString result;
4784 bool temp1 = false ;
4785 bool temp2 = false ;
4786 wxPoint temp4 ;
4787 PyObject * obj0 = 0 ;
4788 PyObject * obj1 = 0 ;
4789 PyObject * obj2 = 0 ;
4790 PyObject * obj3 = 0 ;
4791 PyObject * obj4 = 0 ;
4792 char *kwnames[] = {
4793 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4794 };
4795
4796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4797 if (obj0) {
4798 {
4799 arg1 = wxString_in_helper(obj0);
4800 if (arg1 == NULL) SWIG_fail;
4801 temp1 = true;
4802 }
4803 }
4804 if (obj1) {
4805 {
4806 arg2 = wxString_in_helper(obj1);
4807 if (arg2 == NULL) SWIG_fail;
4808 temp2 = true;
4809 }
4810 }
4811 if (obj2) {
4812 {
4813 arg3 = (long)(SWIG_As_long(obj2));
4814 if (SWIG_arg_fail(3)) SWIG_fail;
4815 }
4816 }
4817 if (obj3) {
4818 {
4819 arg4 = &temp4;
4820 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4821 }
4822 }
4823 if (obj4) {
4824 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4825 if (SWIG_arg_fail(5)) SWIG_fail;
4826 }
4827 {
4828 if (!wxPyCheckForApp()) SWIG_fail;
4829 PyThreadState* __tstate = wxPyBeginAllowThreads();
4830 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4831
4832 wxPyEndAllowThreads(__tstate);
4833 if (PyErr_Occurred()) SWIG_fail;
4834 }
4835 {
4836 #if wxUSE_UNICODE
4837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4838 #else
4839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4840 #endif
4841 }
4842 {
4843 if (temp1)
4844 delete arg1;
4845 }
4846 {
4847 if (temp2)
4848 delete arg2;
4849 }
4850 return resultobj;
4851 fail:
4852 {
4853 if (temp1)
4854 delete arg1;
4855 }
4856 {
4857 if (temp2)
4858 delete arg2;
4859 }
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxString *arg1 = 0 ;
4867 wxString const &arg2_defvalue = wxPyEmptyString ;
4868 wxString *arg2 = (wxString *) &arg2_defvalue ;
4869 wxString const &arg3_defvalue = wxPyEmptyString ;
4870 wxString *arg3 = (wxString *) &arg3_defvalue ;
4871 wxWindow *arg4 = (wxWindow *) NULL ;
4872 int arg5 = (int) -1 ;
4873 int arg6 = (int) -1 ;
4874 bool arg7 = (bool) true ;
4875 wxString result;
4876 bool temp1 = false ;
4877 bool temp2 = false ;
4878 bool temp3 = false ;
4879 PyObject * obj0 = 0 ;
4880 PyObject * obj1 = 0 ;
4881 PyObject * obj2 = 0 ;
4882 PyObject * obj3 = 0 ;
4883 PyObject * obj4 = 0 ;
4884 PyObject * obj5 = 0 ;
4885 PyObject * obj6 = 0 ;
4886 char *kwnames[] = {
4887 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4888 };
4889
4890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4891 {
4892 arg1 = wxString_in_helper(obj0);
4893 if (arg1 == NULL) SWIG_fail;
4894 temp1 = true;
4895 }
4896 if (obj1) {
4897 {
4898 arg2 = wxString_in_helper(obj1);
4899 if (arg2 == NULL) SWIG_fail;
4900 temp2 = true;
4901 }
4902 }
4903 if (obj2) {
4904 {
4905 arg3 = wxString_in_helper(obj2);
4906 if (arg3 == NULL) SWIG_fail;
4907 temp3 = true;
4908 }
4909 }
4910 if (obj3) {
4911 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4912 if (SWIG_arg_fail(4)) SWIG_fail;
4913 }
4914 if (obj4) {
4915 {
4916 arg5 = (int)(SWIG_As_int(obj4));
4917 if (SWIG_arg_fail(5)) SWIG_fail;
4918 }
4919 }
4920 if (obj5) {
4921 {
4922 arg6 = (int)(SWIG_As_int(obj5));
4923 if (SWIG_arg_fail(6)) SWIG_fail;
4924 }
4925 }
4926 if (obj6) {
4927 {
4928 arg7 = (bool)(SWIG_As_bool(obj6));
4929 if (SWIG_arg_fail(7)) SWIG_fail;
4930 }
4931 }
4932 {
4933 if (!wxPyCheckForApp()) SWIG_fail;
4934 PyThreadState* __tstate = wxPyBeginAllowThreads();
4935 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4936
4937 wxPyEndAllowThreads(__tstate);
4938 if (PyErr_Occurred()) SWIG_fail;
4939 }
4940 {
4941 #if wxUSE_UNICODE
4942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4943 #else
4944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4945 #endif
4946 }
4947 {
4948 if (temp1)
4949 delete arg1;
4950 }
4951 {
4952 if (temp2)
4953 delete arg2;
4954 }
4955 {
4956 if (temp3)
4957 delete arg3;
4958 }
4959 return resultobj;
4960 fail:
4961 {
4962 if (temp1)
4963 delete arg1;
4964 }
4965 {
4966 if (temp2)
4967 delete arg2;
4968 }
4969 {
4970 if (temp3)
4971 delete arg3;
4972 }
4973 return NULL;
4974 }
4975
4976
4977 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4978 PyObject *resultobj;
4979 wxString *arg1 = 0 ;
4980 wxString const &arg2_defvalue = wxPyEmptyString ;
4981 wxString *arg2 = (wxString *) &arg2_defvalue ;
4982 wxString const &arg3_defvalue = wxPyEmptyString ;
4983 wxString *arg3 = (wxString *) &arg3_defvalue ;
4984 wxWindow *arg4 = (wxWindow *) NULL ;
4985 wxString result;
4986 bool temp1 = false ;
4987 bool temp2 = false ;
4988 bool temp3 = false ;
4989 PyObject * obj0 = 0 ;
4990 PyObject * obj1 = 0 ;
4991 PyObject * obj2 = 0 ;
4992 PyObject * obj3 = 0 ;
4993 char *kwnames[] = {
4994 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
4995 };
4996
4997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4998 {
4999 arg1 = wxString_in_helper(obj0);
5000 if (arg1 == NULL) SWIG_fail;
5001 temp1 = true;
5002 }
5003 if (obj1) {
5004 {
5005 arg2 = wxString_in_helper(obj1);
5006 if (arg2 == NULL) SWIG_fail;
5007 temp2 = true;
5008 }
5009 }
5010 if (obj2) {
5011 {
5012 arg3 = wxString_in_helper(obj2);
5013 if (arg3 == NULL) SWIG_fail;
5014 temp3 = true;
5015 }
5016 }
5017 if (obj3) {
5018 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5019 if (SWIG_arg_fail(4)) SWIG_fail;
5020 }
5021 {
5022 if (!wxPyCheckForApp()) SWIG_fail;
5023 PyThreadState* __tstate = wxPyBeginAllowThreads();
5024 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5025
5026 wxPyEndAllowThreads(__tstate);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 {
5030 #if wxUSE_UNICODE
5031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5032 #else
5033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5034 #endif
5035 }
5036 {
5037 if (temp1)
5038 delete arg1;
5039 }
5040 {
5041 if (temp2)
5042 delete arg2;
5043 }
5044 {
5045 if (temp3)
5046 delete arg3;
5047 }
5048 return resultobj;
5049 fail:
5050 {
5051 if (temp1)
5052 delete arg1;
5053 }
5054 {
5055 if (temp2)
5056 delete arg2;
5057 }
5058 {
5059 if (temp3)
5060 delete arg3;
5061 }
5062 return NULL;
5063 }
5064
5065
5066 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj;
5068 wxString *arg1 = 0 ;
5069 wxString *arg2 = 0 ;
5070 int arg3 ;
5071 wxString *arg4 = (wxString *) 0 ;
5072 wxWindow *arg5 = (wxWindow *) NULL ;
5073 int arg6 = (int) -1 ;
5074 int arg7 = (int) -1 ;
5075 bool arg8 = (bool) true ;
5076 int arg9 = (int) 150 ;
5077 int arg10 = (int) 200 ;
5078 wxString result;
5079 bool temp1 = false ;
5080 bool temp2 = false ;
5081 PyObject * obj0 = 0 ;
5082 PyObject * obj1 = 0 ;
5083 PyObject * obj2 = 0 ;
5084 PyObject * obj3 = 0 ;
5085 PyObject * obj4 = 0 ;
5086 PyObject * obj5 = 0 ;
5087 PyObject * obj6 = 0 ;
5088 PyObject * obj7 = 0 ;
5089 PyObject * obj8 = 0 ;
5090 char *kwnames[] = {
5091 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5092 };
5093
5094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5095 {
5096 arg1 = wxString_in_helper(obj0);
5097 if (arg1 == NULL) SWIG_fail;
5098 temp1 = true;
5099 }
5100 {
5101 arg2 = wxString_in_helper(obj1);
5102 if (arg2 == NULL) SWIG_fail;
5103 temp2 = true;
5104 }
5105 {
5106 arg3 = PyList_Size(obj2);
5107 arg4 = wxString_LIST_helper(obj2);
5108 if (arg4 == NULL) SWIG_fail;
5109 }
5110 if (obj3) {
5111 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5112 if (SWIG_arg_fail(5)) SWIG_fail;
5113 }
5114 if (obj4) {
5115 {
5116 arg6 = (int)(SWIG_As_int(obj4));
5117 if (SWIG_arg_fail(6)) SWIG_fail;
5118 }
5119 }
5120 if (obj5) {
5121 {
5122 arg7 = (int)(SWIG_As_int(obj5));
5123 if (SWIG_arg_fail(7)) SWIG_fail;
5124 }
5125 }
5126 if (obj6) {
5127 {
5128 arg8 = (bool)(SWIG_As_bool(obj6));
5129 if (SWIG_arg_fail(8)) SWIG_fail;
5130 }
5131 }
5132 if (obj7) {
5133 {
5134 arg9 = (int)(SWIG_As_int(obj7));
5135 if (SWIG_arg_fail(9)) SWIG_fail;
5136 }
5137 }
5138 if (obj8) {
5139 {
5140 arg10 = (int)(SWIG_As_int(obj8));
5141 if (SWIG_arg_fail(10)) SWIG_fail;
5142 }
5143 }
5144 {
5145 if (!wxPyCheckForApp()) SWIG_fail;
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5148
5149 wxPyEndAllowThreads(__tstate);
5150 if (PyErr_Occurred()) SWIG_fail;
5151 }
5152 {
5153 #if wxUSE_UNICODE
5154 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5155 #else
5156 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5157 #endif
5158 }
5159 {
5160 if (temp1)
5161 delete arg1;
5162 }
5163 {
5164 if (temp2)
5165 delete arg2;
5166 }
5167 {
5168 if (arg4) delete [] arg4;
5169 }
5170 return resultobj;
5171 fail:
5172 {
5173 if (temp1)
5174 delete arg1;
5175 }
5176 {
5177 if (temp2)
5178 delete arg2;
5179 }
5180 {
5181 if (arg4) delete [] arg4;
5182 }
5183 return NULL;
5184 }
5185
5186
5187 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5188 PyObject *resultobj;
5189 wxString *arg1 = 0 ;
5190 wxString *arg2 = 0 ;
5191 int arg3 ;
5192 wxString *arg4 = (wxString *) 0 ;
5193 wxWindow *arg5 = (wxWindow *) NULL ;
5194 int arg6 = (int) -1 ;
5195 int arg7 = (int) -1 ;
5196 bool arg8 = (bool) true ;
5197 int arg9 = (int) 150 ;
5198 int arg10 = (int) 200 ;
5199 int result;
5200 bool temp1 = false ;
5201 bool temp2 = false ;
5202 PyObject * obj0 = 0 ;
5203 PyObject * obj1 = 0 ;
5204 PyObject * obj2 = 0 ;
5205 PyObject * obj3 = 0 ;
5206 PyObject * obj4 = 0 ;
5207 PyObject * obj5 = 0 ;
5208 PyObject * obj6 = 0 ;
5209 PyObject * obj7 = 0 ;
5210 PyObject * obj8 = 0 ;
5211 char *kwnames[] = {
5212 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5213 };
5214
5215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5216 {
5217 arg1 = wxString_in_helper(obj0);
5218 if (arg1 == NULL) SWIG_fail;
5219 temp1 = true;
5220 }
5221 {
5222 arg2 = wxString_in_helper(obj1);
5223 if (arg2 == NULL) SWIG_fail;
5224 temp2 = true;
5225 }
5226 {
5227 arg3 = PyList_Size(obj2);
5228 arg4 = wxString_LIST_helper(obj2);
5229 if (arg4 == NULL) SWIG_fail;
5230 }
5231 if (obj3) {
5232 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(5)) SWIG_fail;
5234 }
5235 if (obj4) {
5236 {
5237 arg6 = (int)(SWIG_As_int(obj4));
5238 if (SWIG_arg_fail(6)) SWIG_fail;
5239 }
5240 }
5241 if (obj5) {
5242 {
5243 arg7 = (int)(SWIG_As_int(obj5));
5244 if (SWIG_arg_fail(7)) SWIG_fail;
5245 }
5246 }
5247 if (obj6) {
5248 {
5249 arg8 = (bool)(SWIG_As_bool(obj6));
5250 if (SWIG_arg_fail(8)) SWIG_fail;
5251 }
5252 }
5253 if (obj7) {
5254 {
5255 arg9 = (int)(SWIG_As_int(obj7));
5256 if (SWIG_arg_fail(9)) SWIG_fail;
5257 }
5258 }
5259 if (obj8) {
5260 {
5261 arg10 = (int)(SWIG_As_int(obj8));
5262 if (SWIG_arg_fail(10)) SWIG_fail;
5263 }
5264 }
5265 {
5266 if (!wxPyCheckForApp()) SWIG_fail;
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 resultobj = SWIG_From_int((int)(result));
5275 }
5276 {
5277 if (temp1)
5278 delete arg1;
5279 }
5280 {
5281 if (temp2)
5282 delete arg2;
5283 }
5284 {
5285 if (arg4) delete [] arg4;
5286 }
5287 return resultobj;
5288 fail:
5289 {
5290 if (temp1)
5291 delete arg1;
5292 }
5293 {
5294 if (temp2)
5295 delete arg2;
5296 }
5297 {
5298 if (arg4) delete [] arg4;
5299 }
5300 return NULL;
5301 }
5302
5303
5304 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5305 PyObject *resultobj;
5306 wxString *arg1 = 0 ;
5307 wxString const &arg2_defvalue = wxPyEmptyString ;
5308 wxString *arg2 = (wxString *) &arg2_defvalue ;
5309 int arg3 = (int) wxOK|wxCENTRE ;
5310 wxWindow *arg4 = (wxWindow *) NULL ;
5311 int arg5 = (int) -1 ;
5312 int arg6 = (int) -1 ;
5313 int result;
5314 bool temp1 = false ;
5315 bool temp2 = false ;
5316 PyObject * obj0 = 0 ;
5317 PyObject * obj1 = 0 ;
5318 PyObject * obj2 = 0 ;
5319 PyObject * obj3 = 0 ;
5320 PyObject * obj4 = 0 ;
5321 PyObject * obj5 = 0 ;
5322 char *kwnames[] = {
5323 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5324 };
5325
5326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5327 {
5328 arg1 = wxString_in_helper(obj0);
5329 if (arg1 == NULL) SWIG_fail;
5330 temp1 = true;
5331 }
5332 if (obj1) {
5333 {
5334 arg2 = wxString_in_helper(obj1);
5335 if (arg2 == NULL) SWIG_fail;
5336 temp2 = true;
5337 }
5338 }
5339 if (obj2) {
5340 {
5341 arg3 = (int)(SWIG_As_int(obj2));
5342 if (SWIG_arg_fail(3)) SWIG_fail;
5343 }
5344 }
5345 if (obj3) {
5346 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5347 if (SWIG_arg_fail(4)) SWIG_fail;
5348 }
5349 if (obj4) {
5350 {
5351 arg5 = (int)(SWIG_As_int(obj4));
5352 if (SWIG_arg_fail(5)) SWIG_fail;
5353 }
5354 }
5355 if (obj5) {
5356 {
5357 arg6 = (int)(SWIG_As_int(obj5));
5358 if (SWIG_arg_fail(6)) SWIG_fail;
5359 }
5360 }
5361 {
5362 if (!wxPyCheckForApp()) SWIG_fail;
5363 PyThreadState* __tstate = wxPyBeginAllowThreads();
5364 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5365
5366 wxPyEndAllowThreads(__tstate);
5367 if (PyErr_Occurred()) SWIG_fail;
5368 }
5369 {
5370 resultobj = SWIG_From_int((int)(result));
5371 }
5372 {
5373 if (temp1)
5374 delete arg1;
5375 }
5376 {
5377 if (temp2)
5378 delete arg2;
5379 }
5380 return resultobj;
5381 fail:
5382 {
5383 if (temp1)
5384 delete arg1;
5385 }
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 return NULL;
5391 }
5392
5393
5394 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5395 PyObject *resultobj;
5396 wxString *arg1 = 0 ;
5397 wxString *arg2 = 0 ;
5398 wxString *arg3 = 0 ;
5399 long arg4 ;
5400 long arg5 = (long) 0 ;
5401 long arg6 = (long) 100 ;
5402 wxWindow *arg7 = (wxWindow *) NULL ;
5403 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5404 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5405 long result;
5406 bool temp1 = false ;
5407 bool temp2 = false ;
5408 bool temp3 = false ;
5409 wxPoint temp8 ;
5410 PyObject * obj0 = 0 ;
5411 PyObject * obj1 = 0 ;
5412 PyObject * obj2 = 0 ;
5413 PyObject * obj3 = 0 ;
5414 PyObject * obj4 = 0 ;
5415 PyObject * obj5 = 0 ;
5416 PyObject * obj6 = 0 ;
5417 PyObject * obj7 = 0 ;
5418 char *kwnames[] = {
5419 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5420 };
5421
5422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5423 {
5424 arg1 = wxString_in_helper(obj0);
5425 if (arg1 == NULL) SWIG_fail;
5426 temp1 = true;
5427 }
5428 {
5429 arg2 = wxString_in_helper(obj1);
5430 if (arg2 == NULL) SWIG_fail;
5431 temp2 = true;
5432 }
5433 {
5434 arg3 = wxString_in_helper(obj2);
5435 if (arg3 == NULL) SWIG_fail;
5436 temp3 = true;
5437 }
5438 {
5439 arg4 = (long)(SWIG_As_long(obj3));
5440 if (SWIG_arg_fail(4)) SWIG_fail;
5441 }
5442 if (obj4) {
5443 {
5444 arg5 = (long)(SWIG_As_long(obj4));
5445 if (SWIG_arg_fail(5)) SWIG_fail;
5446 }
5447 }
5448 if (obj5) {
5449 {
5450 arg6 = (long)(SWIG_As_long(obj5));
5451 if (SWIG_arg_fail(6)) SWIG_fail;
5452 }
5453 }
5454 if (obj6) {
5455 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5456 if (SWIG_arg_fail(7)) SWIG_fail;
5457 }
5458 if (obj7) {
5459 {
5460 arg8 = &temp8;
5461 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5462 }
5463 }
5464 {
5465 if (!wxPyCheckForApp()) SWIG_fail;
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 resultobj = SWIG_From_long((long)(result));
5474 }
5475 {
5476 if (temp1)
5477 delete arg1;
5478 }
5479 {
5480 if (temp2)
5481 delete arg2;
5482 }
5483 {
5484 if (temp3)
5485 delete arg3;
5486 }
5487 return resultobj;
5488 fail:
5489 {
5490 if (temp1)
5491 delete arg1;
5492 }
5493 {
5494 if (temp2)
5495 delete arg2;
5496 }
5497 {
5498 if (temp3)
5499 delete arg3;
5500 }
5501 return NULL;
5502 }
5503
5504
5505 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5506 PyObject *resultobj;
5507 bool result;
5508 char *kwnames[] = {
5509 NULL
5510 };
5511
5512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5513 {
5514 if (!wxPyCheckForApp()) SWIG_fail;
5515 PyThreadState* __tstate = wxPyBeginAllowThreads();
5516 result = (bool)wxColourDisplay();
5517
5518 wxPyEndAllowThreads(__tstate);
5519 if (PyErr_Occurred()) SWIG_fail;
5520 }
5521 {
5522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5523 }
5524 return resultobj;
5525 fail:
5526 return NULL;
5527 }
5528
5529
5530 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5531 PyObject *resultobj;
5532 int result;
5533 char *kwnames[] = {
5534 NULL
5535 };
5536
5537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5538 {
5539 if (!wxPyCheckForApp()) SWIG_fail;
5540 PyThreadState* __tstate = wxPyBeginAllowThreads();
5541 result = (int)wxDisplayDepth();
5542
5543 wxPyEndAllowThreads(__tstate);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = SWIG_From_int((int)(result));
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj;
5557 int result;
5558 char *kwnames[] = {
5559 NULL
5560 };
5561
5562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5563 {
5564 if (!wxPyCheckForApp()) SWIG_fail;
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (int)wxGetDisplayDepth();
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 resultobj = SWIG_From_int((int)(result));
5573 }
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj;
5582 int *arg1 = (int *) 0 ;
5583 int *arg2 = (int *) 0 ;
5584 int temp1 ;
5585 int res1 = 0 ;
5586 int temp2 ;
5587 int res2 = 0 ;
5588 char *kwnames[] = {
5589 NULL
5590 };
5591
5592 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5593 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5595 {
5596 if (!wxPyCheckForApp()) SWIG_fail;
5597 PyThreadState* __tstate = wxPyBeginAllowThreads();
5598 wxDisplaySize(arg1,arg2);
5599
5600 wxPyEndAllowThreads(__tstate);
5601 if (PyErr_Occurred()) SWIG_fail;
5602 }
5603 Py_INCREF(Py_None); resultobj = Py_None;
5604 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5605 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5606 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5607 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5615 PyObject *resultobj;
5616 wxSize result;
5617 char *kwnames[] = {
5618 NULL
5619 };
5620
5621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5622 {
5623 if (!wxPyCheckForApp()) SWIG_fail;
5624 PyThreadState* __tstate = wxPyBeginAllowThreads();
5625 result = wxGetDisplaySize();
5626
5627 wxPyEndAllowThreads(__tstate);
5628 if (PyErr_Occurred()) SWIG_fail;
5629 }
5630 {
5631 wxSize * resultptr;
5632 resultptr = new wxSize((wxSize &)(result));
5633 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5634 }
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5642 PyObject *resultobj;
5643 int *arg1 = (int *) 0 ;
5644 int *arg2 = (int *) 0 ;
5645 int temp1 ;
5646 int res1 = 0 ;
5647 int temp2 ;
5648 int res2 = 0 ;
5649 char *kwnames[] = {
5650 NULL
5651 };
5652
5653 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5654 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5656 {
5657 if (!wxPyCheckForApp()) SWIG_fail;
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 wxDisplaySizeMM(arg1,arg2);
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 Py_INCREF(Py_None); resultobj = Py_None;
5665 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5666 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5667 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5668 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5676 PyObject *resultobj;
5677 wxSize result;
5678 char *kwnames[] = {
5679 NULL
5680 };
5681
5682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5683 {
5684 if (!wxPyCheckForApp()) SWIG_fail;
5685 PyThreadState* __tstate = wxPyBeginAllowThreads();
5686 result = wxGetDisplaySizeMM();
5687
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 {
5692 wxSize * resultptr;
5693 resultptr = new wxSize((wxSize &)(result));
5694 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5695 }
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj;
5704 int *arg1 = (int *) 0 ;
5705 int *arg2 = (int *) 0 ;
5706 int *arg3 = (int *) 0 ;
5707 int *arg4 = (int *) 0 ;
5708 int temp1 ;
5709 int res1 = 0 ;
5710 int temp2 ;
5711 int res2 = 0 ;
5712 int temp3 ;
5713 int res3 = 0 ;
5714 int temp4 ;
5715 int res4 = 0 ;
5716 char *kwnames[] = {
5717 NULL
5718 };
5719
5720 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5721 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5722 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5723 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5725 {
5726 if (!wxPyCheckForApp()) SWIG_fail;
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5729
5730 wxPyEndAllowThreads(__tstate);
5731 if (PyErr_Occurred()) SWIG_fail;
5732 }
5733 Py_INCREF(Py_None); resultobj = Py_None;
5734 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5735 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5736 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5737 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5738 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5739 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5740 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5741 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5749 PyObject *resultobj;
5750 wxRect result;
5751 char *kwnames[] = {
5752 NULL
5753 };
5754
5755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5756 {
5757 if (!wxPyCheckForApp()) SWIG_fail;
5758 PyThreadState* __tstate = wxPyBeginAllowThreads();
5759 result = wxGetClientDisplayRect();
5760
5761 wxPyEndAllowThreads(__tstate);
5762 if (PyErr_Occurred()) SWIG_fail;
5763 }
5764 {
5765 wxRect * resultptr;
5766 resultptr = new wxRect((wxRect &)(result));
5767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5768 }
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj;
5777 wxCursor *arg1 = 0 ;
5778 PyObject * obj0 = 0 ;
5779 char *kwnames[] = {
5780 (char *) "cursor", NULL
5781 };
5782
5783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5784 {
5785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5786 if (SWIG_arg_fail(1)) SWIG_fail;
5787 if (arg1 == NULL) {
5788 SWIG_null_ref("wxCursor");
5789 }
5790 if (SWIG_arg_fail(1)) SWIG_fail;
5791 }
5792 {
5793 if (!wxPyCheckForApp()) SWIG_fail;
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 wxSetCursor(*arg1);
5796
5797 wxPyEndAllowThreads(__tstate);
5798 if (PyErr_Occurred()) SWIG_fail;
5799 }
5800 Py_INCREF(Py_None); resultobj = Py_None;
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5808 PyObject *resultobj;
5809 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5810 PyObject * obj0 = 0 ;
5811 char *kwnames[] = {
5812 (char *) "cursor", NULL
5813 };
5814
5815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5816 if (obj0) {
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 }
5820 {
5821 if (!wxPyCheckForApp()) SWIG_fail;
5822 PyThreadState* __tstate = wxPyBeginAllowThreads();
5823 wxBeginBusyCursor(arg1);
5824
5825 wxPyEndAllowThreads(__tstate);
5826 if (PyErr_Occurred()) SWIG_fail;
5827 }
5828 Py_INCREF(Py_None); resultobj = Py_None;
5829 return resultobj;
5830 fail:
5831 return NULL;
5832 }
5833
5834
5835 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5836 PyObject *resultobj;
5837 wxWindow *result;
5838 char *kwnames[] = {
5839 NULL
5840 };
5841
5842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5843 {
5844 if (!wxPyCheckForApp()) SWIG_fail;
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 result = (wxWindow *)wxGetActiveWindow();
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 {
5852 resultobj = wxPyMake_wxObject(result, 0);
5853 }
5854 return resultobj;
5855 fail:
5856 return NULL;
5857 }
5858
5859
5860 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5861 PyObject *resultobj;
5862 wxPoint *arg1 = 0 ;
5863 wxWindow *result;
5864 wxPoint temp1 ;
5865 PyObject * obj0 = 0 ;
5866 char *kwnames[] = {
5867 (char *) "pt", NULL
5868 };
5869
5870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5871 {
5872 arg1 = &temp1;
5873 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5874 }
5875 {
5876 if (!wxPyCheckForApp()) SWIG_fail;
5877 PyThreadState* __tstate = wxPyBeginAllowThreads();
5878 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5879
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 {
5884 resultobj = wxPyMake_wxObject(result, 0);
5885 }
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxPoint *arg1 = 0 ;
5895 wxWindow *result;
5896 wxPoint temp1 ;
5897 PyObject * obj0 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "pt", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5903 {
5904 arg1 = &temp1;
5905 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5906 }
5907 {
5908 if (!wxPyCheckForApp()) SWIG_fail;
5909 PyThreadState* __tstate = wxPyBeginAllowThreads();
5910 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5911
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 {
5916 resultobj = wxPyMake_wxObject(result, 0);
5917 }
5918 return resultobj;
5919 fail:
5920 return NULL;
5921 }
5922
5923
5924 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5925 PyObject *resultobj;
5926 wxWindow *arg1 = (wxWindow *) 0 ;
5927 wxWindow *result;
5928 PyObject * obj0 = 0 ;
5929 char *kwnames[] = {
5930 (char *) "win", NULL
5931 };
5932
5933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5935 if (SWIG_arg_fail(1)) SWIG_fail;
5936 {
5937 if (!wxPyCheckForApp()) SWIG_fail;
5938 PyThreadState* __tstate = wxPyBeginAllowThreads();
5939 result = (wxWindow *)wxGetTopLevelParent(arg1);
5940
5941 wxPyEndAllowThreads(__tstate);
5942 if (PyErr_Occurred()) SWIG_fail;
5943 }
5944 {
5945 resultobj = wxPyMake_wxObject(result, 0);
5946 }
5947 return resultobj;
5948 fail:
5949 return NULL;
5950 }
5951
5952
5953 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5954 PyObject *resultobj;
5955 wxKeyCode arg1 ;
5956 bool result;
5957 PyObject * obj0 = 0 ;
5958 char *kwnames[] = {
5959 (char *) "key", NULL
5960 };
5961
5962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5963 {
5964 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5965 if (SWIG_arg_fail(1)) SWIG_fail;
5966 }
5967 {
5968 if (!wxPyCheckForApp()) SWIG_fail;
5969 PyThreadState* __tstate = wxPyBeginAllowThreads();
5970 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5971
5972 wxPyEndAllowThreads(__tstate);
5973 if (PyErr_Occurred()) SWIG_fail;
5974 }
5975 {
5976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5977 }
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 char *kwnames[] = {
5987 NULL
5988 };
5989
5990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
5991 {
5992 if (!wxPyCheckForApp()) SWIG_fail;
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 wxWakeUpMainThread();
5995
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 Py_INCREF(Py_None); resultobj = Py_None;
6000 return resultobj;
6001 fail:
6002 return NULL;
6003 }
6004
6005
6006 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6007 PyObject *resultobj;
6008 char *kwnames[] = {
6009 NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6013 {
6014 if (!wxPyCheckForApp()) SWIG_fail;
6015 PyThreadState* __tstate = wxPyBeginAllowThreads();
6016 wxMutexGuiEnter();
6017
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 Py_INCREF(Py_None); resultobj = Py_None;
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6029 PyObject *resultobj;
6030 char *kwnames[] = {
6031 NULL
6032 };
6033
6034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6035 {
6036 if (!wxPyCheckForApp()) SWIG_fail;
6037 PyThreadState* __tstate = wxPyBeginAllowThreads();
6038 wxMutexGuiLeave();
6039
6040 wxPyEndAllowThreads(__tstate);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 Py_INCREF(Py_None); resultobj = Py_None;
6044 return resultobj;
6045 fail:
6046 return NULL;
6047 }
6048
6049
6050 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6051 PyObject *resultobj;
6052 wxMutexGuiLocker *result;
6053 char *kwnames[] = {
6054 NULL
6055 };
6056
6057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6058 {
6059 if (!wxPyCheckForApp()) SWIG_fail;
6060 PyThreadState* __tstate = wxPyBeginAllowThreads();
6061 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6062
6063 wxPyEndAllowThreads(__tstate);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6067 return resultobj;
6068 fail:
6069 return NULL;
6070 }
6071
6072
6073 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6074 PyObject *resultobj;
6075 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6076 PyObject * obj0 = 0 ;
6077 char *kwnames[] = {
6078 (char *) "self", NULL
6079 };
6080
6081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6083 if (SWIG_arg_fail(1)) SWIG_fail;
6084 {
6085 PyThreadState* __tstate = wxPyBeginAllowThreads();
6086 delete arg1;
6087
6088 wxPyEndAllowThreads(__tstate);
6089 if (PyErr_Occurred()) SWIG_fail;
6090 }
6091 Py_INCREF(Py_None); resultobj = Py_None;
6092 return resultobj;
6093 fail:
6094 return NULL;
6095 }
6096
6097
6098 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6099 PyObject *obj;
6100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6101 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6102 Py_INCREF(obj);
6103 return Py_BuildValue((char *)"");
6104 }
6105 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6106 PyObject *resultobj;
6107 bool result;
6108 char *kwnames[] = {
6109 NULL
6110 };
6111
6112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (bool)wxThread_IsMain();
6116
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj;
6131 wxString *arg1 = 0 ;
6132 wxToolTip *result;
6133 bool temp1 = false ;
6134 PyObject * obj0 = 0 ;
6135 char *kwnames[] = {
6136 (char *) "tip", NULL
6137 };
6138
6139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6140 {
6141 arg1 = wxString_in_helper(obj0);
6142 if (arg1 == NULL) SWIG_fail;
6143 temp1 = true;
6144 }
6145 {
6146 if (!wxPyCheckForApp()) SWIG_fail;
6147 PyThreadState* __tstate = wxPyBeginAllowThreads();
6148 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6149
6150 wxPyEndAllowThreads(__tstate);
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 {
6154 resultobj = wxPyMake_wxObject(result, 1);
6155 }
6156 {
6157 if (temp1)
6158 delete arg1;
6159 }
6160 return resultobj;
6161 fail:
6162 {
6163 if (temp1)
6164 delete arg1;
6165 }
6166 return NULL;
6167 }
6168
6169
6170 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6171 PyObject *resultobj;
6172 wxToolTip *arg1 = (wxToolTip *) 0 ;
6173 wxString *arg2 = 0 ;
6174 bool temp2 = false ;
6175 PyObject * obj0 = 0 ;
6176 PyObject * obj1 = 0 ;
6177 char *kwnames[] = {
6178 (char *) "self",(char *) "tip", NULL
6179 };
6180
6181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6183 if (SWIG_arg_fail(1)) SWIG_fail;
6184 {
6185 arg2 = wxString_in_helper(obj1);
6186 if (arg2 == NULL) SWIG_fail;
6187 temp2 = true;
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 (arg1)->SetTip((wxString const &)*arg2);
6192
6193 wxPyEndAllowThreads(__tstate);
6194 if (PyErr_Occurred()) SWIG_fail;
6195 }
6196 Py_INCREF(Py_None); resultobj = Py_None;
6197 {
6198 if (temp2)
6199 delete arg2;
6200 }
6201 return resultobj;
6202 fail:
6203 {
6204 if (temp2)
6205 delete arg2;
6206 }
6207 return NULL;
6208 }
6209
6210
6211 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6212 PyObject *resultobj;
6213 wxToolTip *arg1 = (wxToolTip *) 0 ;
6214 wxString result;
6215 PyObject * obj0 = 0 ;
6216 char *kwnames[] = {
6217 (char *) "self", NULL
6218 };
6219
6220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6222 if (SWIG_arg_fail(1)) SWIG_fail;
6223 {
6224 PyThreadState* __tstate = wxPyBeginAllowThreads();
6225 result = (arg1)->GetTip();
6226
6227 wxPyEndAllowThreads(__tstate);
6228 if (PyErr_Occurred()) SWIG_fail;
6229 }
6230 {
6231 #if wxUSE_UNICODE
6232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6233 #else
6234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6235 #endif
6236 }
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6244 PyObject *resultobj;
6245 wxToolTip *arg1 = (wxToolTip *) 0 ;
6246 wxWindow *result;
6247 PyObject * obj0 = 0 ;
6248 char *kwnames[] = {
6249 (char *) "self", NULL
6250 };
6251
6252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6254 if (SWIG_arg_fail(1)) SWIG_fail;
6255 {
6256 PyThreadState* __tstate = wxPyBeginAllowThreads();
6257 result = (wxWindow *)(arg1)->GetWindow();
6258
6259 wxPyEndAllowThreads(__tstate);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 {
6263 resultobj = wxPyMake_wxObject(result, 0);
6264 }
6265 return resultobj;
6266 fail:
6267 return NULL;
6268 }
6269
6270
6271 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6272 PyObject *resultobj;
6273 bool arg1 ;
6274 PyObject * obj0 = 0 ;
6275 char *kwnames[] = {
6276 (char *) "flag", NULL
6277 };
6278
6279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6280 {
6281 arg1 = (bool)(SWIG_As_bool(obj0));
6282 if (SWIG_arg_fail(1)) SWIG_fail;
6283 }
6284 {
6285 PyThreadState* __tstate = wxPyBeginAllowThreads();
6286 wxToolTip::Enable(arg1);
6287
6288 wxPyEndAllowThreads(__tstate);
6289 if (PyErr_Occurred()) SWIG_fail;
6290 }
6291 Py_INCREF(Py_None); resultobj = Py_None;
6292 return resultobj;
6293 fail:
6294 return NULL;
6295 }
6296
6297
6298 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6299 PyObject *resultobj;
6300 long arg1 ;
6301 PyObject * obj0 = 0 ;
6302 char *kwnames[] = {
6303 (char *) "milliseconds", NULL
6304 };
6305
6306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6307 {
6308 arg1 = (long)(SWIG_As_long(obj0));
6309 if (SWIG_arg_fail(1)) SWIG_fail;
6310 }
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 wxToolTip::SetDelay(arg1);
6314
6315 wxPyEndAllowThreads(__tstate);
6316 if (PyErr_Occurred()) SWIG_fail;
6317 }
6318 Py_INCREF(Py_None); resultobj = Py_None;
6319 return resultobj;
6320 fail:
6321 return NULL;
6322 }
6323
6324
6325 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6326 PyObject *obj;
6327 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6328 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6329 Py_INCREF(obj);
6330 return Py_BuildValue((char *)"");
6331 }
6332 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6333 PyObject *resultobj;
6334 wxWindow *arg1 = (wxWindow *) 0 ;
6335 wxSize *arg2 = 0 ;
6336 wxCaret *result;
6337 wxSize temp2 ;
6338 PyObject * obj0 = 0 ;
6339 PyObject * obj1 = 0 ;
6340 char *kwnames[] = {
6341 (char *) "window",(char *) "size", NULL
6342 };
6343
6344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6346 if (SWIG_arg_fail(1)) SWIG_fail;
6347 {
6348 arg2 = &temp2;
6349 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6350 }
6351 {
6352 if (!wxPyCheckForApp()) SWIG_fail;
6353 PyThreadState* __tstate = wxPyBeginAllowThreads();
6354 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6355
6356 wxPyEndAllowThreads(__tstate);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj;
6368 wxCaret *arg1 = (wxCaret *) 0 ;
6369 PyObject * obj0 = 0 ;
6370 char *kwnames[] = {
6371 (char *) "self", NULL
6372 };
6373
6374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6376 if (SWIG_arg_fail(1)) SWIG_fail;
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 wxCaret_Destroy(arg1);
6380
6381 wxPyEndAllowThreads(__tstate);
6382 if (PyErr_Occurred()) SWIG_fail;
6383 }
6384 Py_INCREF(Py_None); resultobj = Py_None;
6385 return resultobj;
6386 fail:
6387 return NULL;
6388 }
6389
6390
6391 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6392 PyObject *resultobj;
6393 wxCaret *arg1 = (wxCaret *) 0 ;
6394 bool result;
6395 PyObject * obj0 = 0 ;
6396 char *kwnames[] = {
6397 (char *) "self", NULL
6398 };
6399
6400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6402 if (SWIG_arg_fail(1)) SWIG_fail;
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 result = (bool)(arg1)->IsOk();
6406
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 {
6411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6412 }
6413 return resultobj;
6414 fail:
6415 return NULL;
6416 }
6417
6418
6419 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6420 PyObject *resultobj;
6421 wxCaret *arg1 = (wxCaret *) 0 ;
6422 bool result;
6423 PyObject * obj0 = 0 ;
6424 char *kwnames[] = {
6425 (char *) "self", NULL
6426 };
6427
6428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6430 if (SWIG_arg_fail(1)) SWIG_fail;
6431 {
6432 PyThreadState* __tstate = wxPyBeginAllowThreads();
6433 result = (bool)(arg1)->IsVisible();
6434
6435 wxPyEndAllowThreads(__tstate);
6436 if (PyErr_Occurred()) SWIG_fail;
6437 }
6438 {
6439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6440 }
6441 return resultobj;
6442 fail:
6443 return NULL;
6444 }
6445
6446
6447 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6448 PyObject *resultobj;
6449 wxCaret *arg1 = (wxCaret *) 0 ;
6450 wxPoint result;
6451 PyObject * obj0 = 0 ;
6452 char *kwnames[] = {
6453 (char *) "self", NULL
6454 };
6455
6456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6458 if (SWIG_arg_fail(1)) SWIG_fail;
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 result = (arg1)->GetPosition();
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 {
6467 wxPoint * resultptr;
6468 resultptr = new wxPoint((wxPoint &)(result));
6469 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6470 }
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6478 PyObject *resultobj;
6479 wxCaret *arg1 = (wxCaret *) 0 ;
6480 int *arg2 = (int *) 0 ;
6481 int *arg3 = (int *) 0 ;
6482 int temp2 ;
6483 int res2 = 0 ;
6484 int temp3 ;
6485 int res3 = 0 ;
6486 PyObject * obj0 = 0 ;
6487 char *kwnames[] = {
6488 (char *) "self", NULL
6489 };
6490
6491 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6492 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6495 if (SWIG_arg_fail(1)) SWIG_fail;
6496 {
6497 PyThreadState* __tstate = wxPyBeginAllowThreads();
6498 (arg1)->GetPosition(arg2,arg3);
6499
6500 wxPyEndAllowThreads(__tstate);
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 Py_INCREF(Py_None); resultobj = Py_None;
6504 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6505 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6506 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6507 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6515 PyObject *resultobj;
6516 wxCaret *arg1 = (wxCaret *) 0 ;
6517 wxSize result;
6518 PyObject * obj0 = 0 ;
6519 char *kwnames[] = {
6520 (char *) "self", NULL
6521 };
6522
6523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6525 if (SWIG_arg_fail(1)) SWIG_fail;
6526 {
6527 PyThreadState* __tstate = wxPyBeginAllowThreads();
6528 result = (arg1)->GetSize();
6529
6530 wxPyEndAllowThreads(__tstate);
6531 if (PyErr_Occurred()) SWIG_fail;
6532 }
6533 {
6534 wxSize * resultptr;
6535 resultptr = new wxSize((wxSize &)(result));
6536 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6537 }
6538 return resultobj;
6539 fail:
6540 return NULL;
6541 }
6542
6543
6544 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6545 PyObject *resultobj;
6546 wxCaret *arg1 = (wxCaret *) 0 ;
6547 int *arg2 = (int *) 0 ;
6548 int *arg3 = (int *) 0 ;
6549 int temp2 ;
6550 int res2 = 0 ;
6551 int temp3 ;
6552 int res3 = 0 ;
6553 PyObject * obj0 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "self", NULL
6556 };
6557
6558 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6559 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6562 if (SWIG_arg_fail(1)) SWIG_fail;
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 (arg1)->GetSize(arg2,arg3);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 Py_INCREF(Py_None); resultobj = Py_None;
6571 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6572 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6573 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6574 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6575 return resultobj;
6576 fail:
6577 return NULL;
6578 }
6579
6580
6581 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6582 PyObject *resultobj;
6583 wxCaret *arg1 = (wxCaret *) 0 ;
6584 wxWindow *result;
6585 PyObject * obj0 = 0 ;
6586 char *kwnames[] = {
6587 (char *) "self", NULL
6588 };
6589
6590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6592 if (SWIG_arg_fail(1)) SWIG_fail;
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 result = (wxWindow *)(arg1)->GetWindow();
6596
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 {
6601 resultobj = wxPyMake_wxObject(result, 0);
6602 }
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj;
6611 wxCaret *arg1 = (wxCaret *) 0 ;
6612 int arg2 ;
6613 int arg3 ;
6614 PyObject * obj0 = 0 ;
6615 PyObject * obj1 = 0 ;
6616 PyObject * obj2 = 0 ;
6617 char *kwnames[] = {
6618 (char *) "self",(char *) "x",(char *) "y", NULL
6619 };
6620
6621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6623 if (SWIG_arg_fail(1)) SWIG_fail;
6624 {
6625 arg2 = (int)(SWIG_As_int(obj1));
6626 if (SWIG_arg_fail(2)) SWIG_fail;
6627 }
6628 {
6629 arg3 = (int)(SWIG_As_int(obj2));
6630 if (SWIG_arg_fail(3)) SWIG_fail;
6631 }
6632 {
6633 PyThreadState* __tstate = wxPyBeginAllowThreads();
6634 (arg1)->Move(arg2,arg3);
6635
6636 wxPyEndAllowThreads(__tstate);
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 Py_INCREF(Py_None); resultobj = Py_None;
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj;
6648 wxCaret *arg1 = (wxCaret *) 0 ;
6649 wxPoint *arg2 = 0 ;
6650 wxPoint temp2 ;
6651 PyObject * obj0 = 0 ;
6652 PyObject * obj1 = 0 ;
6653 char *kwnames[] = {
6654 (char *) "self",(char *) "pt", NULL
6655 };
6656
6657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6659 if (SWIG_arg_fail(1)) SWIG_fail;
6660 {
6661 arg2 = &temp2;
6662 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 (arg1)->Move((wxPoint const &)*arg2);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 Py_INCREF(Py_None); resultobj = Py_None;
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj;
6680 wxCaret *arg1 = (wxCaret *) 0 ;
6681 int arg2 ;
6682 int arg3 ;
6683 PyObject * obj0 = 0 ;
6684 PyObject * obj1 = 0 ;
6685 PyObject * obj2 = 0 ;
6686 char *kwnames[] = {
6687 (char *) "self",(char *) "width",(char *) "height", NULL
6688 };
6689
6690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6692 if (SWIG_arg_fail(1)) SWIG_fail;
6693 {
6694 arg2 = (int)(SWIG_As_int(obj1));
6695 if (SWIG_arg_fail(2)) SWIG_fail;
6696 }
6697 {
6698 arg3 = (int)(SWIG_As_int(obj2));
6699 if (SWIG_arg_fail(3)) SWIG_fail;
6700 }
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 (arg1)->SetSize(arg2,arg3);
6704
6705 wxPyEndAllowThreads(__tstate);
6706 if (PyErr_Occurred()) SWIG_fail;
6707 }
6708 Py_INCREF(Py_None); resultobj = Py_None;
6709 return resultobj;
6710 fail:
6711 return NULL;
6712 }
6713
6714
6715 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6716 PyObject *resultobj;
6717 wxCaret *arg1 = (wxCaret *) 0 ;
6718 wxSize *arg2 = 0 ;
6719 wxSize temp2 ;
6720 PyObject * obj0 = 0 ;
6721 PyObject * obj1 = 0 ;
6722 char *kwnames[] = {
6723 (char *) "self",(char *) "size", NULL
6724 };
6725
6726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6728 if (SWIG_arg_fail(1)) SWIG_fail;
6729 {
6730 arg2 = &temp2;
6731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6732 }
6733 {
6734 PyThreadState* __tstate = wxPyBeginAllowThreads();
6735 (arg1)->SetSize((wxSize const &)*arg2);
6736
6737 wxPyEndAllowThreads(__tstate);
6738 if (PyErr_Occurred()) SWIG_fail;
6739 }
6740 Py_INCREF(Py_None); resultobj = Py_None;
6741 return resultobj;
6742 fail:
6743 return NULL;
6744 }
6745
6746
6747 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6748 PyObject *resultobj;
6749 wxCaret *arg1 = (wxCaret *) 0 ;
6750 int arg2 = (int) true ;
6751 PyObject * obj0 = 0 ;
6752 PyObject * obj1 = 0 ;
6753 char *kwnames[] = {
6754 (char *) "self",(char *) "show", NULL
6755 };
6756
6757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6759 if (SWIG_arg_fail(1)) SWIG_fail;
6760 if (obj1) {
6761 {
6762 arg2 = (int)(SWIG_As_int(obj1));
6763 if (SWIG_arg_fail(2)) SWIG_fail;
6764 }
6765 }
6766 {
6767 PyThreadState* __tstate = wxPyBeginAllowThreads();
6768 (arg1)->Show(arg2);
6769
6770 wxPyEndAllowThreads(__tstate);
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 Py_INCREF(Py_None); resultobj = Py_None;
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6781 PyObject *resultobj;
6782 wxCaret *arg1 = (wxCaret *) 0 ;
6783 PyObject * obj0 = 0 ;
6784 char *kwnames[] = {
6785 (char *) "self", NULL
6786 };
6787
6788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6790 if (SWIG_arg_fail(1)) SWIG_fail;
6791 {
6792 PyThreadState* __tstate = wxPyBeginAllowThreads();
6793 (arg1)->Hide();
6794
6795 wxPyEndAllowThreads(__tstate);
6796 if (PyErr_Occurred()) SWIG_fail;
6797 }
6798 Py_INCREF(Py_None); resultobj = Py_None;
6799 return resultobj;
6800 fail:
6801 return NULL;
6802 }
6803
6804
6805 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6806 PyObject *resultobj;
6807 int result;
6808 char *kwnames[] = {
6809 NULL
6810 };
6811
6812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6813 {
6814 PyThreadState* __tstate = wxPyBeginAllowThreads();
6815 result = (int)wxCaret::GetBlinkTime();
6816
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 {
6821 resultobj = SWIG_From_int((int)(result));
6822 }
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6830 PyObject *resultobj;
6831 int arg1 ;
6832 PyObject * obj0 = 0 ;
6833 char *kwnames[] = {
6834 (char *) "milliseconds", NULL
6835 };
6836
6837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6838 {
6839 arg1 = (int)(SWIG_As_int(obj0));
6840 if (SWIG_arg_fail(1)) SWIG_fail;
6841 }
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 wxCaret::SetBlinkTime(arg1);
6845
6846 wxPyEndAllowThreads(__tstate);
6847 if (PyErr_Occurred()) SWIG_fail;
6848 }
6849 Py_INCREF(Py_None); resultobj = Py_None;
6850 return resultobj;
6851 fail:
6852 return NULL;
6853 }
6854
6855
6856 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6857 PyObject *obj;
6858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6859 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6860 Py_INCREF(obj);
6861 return Py_BuildValue((char *)"");
6862 }
6863 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj;
6865 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6866 wxBusyCursor *result;
6867 PyObject * obj0 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "cursor", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6873 if (obj0) {
6874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6875 if (SWIG_arg_fail(1)) SWIG_fail;
6876 }
6877 {
6878 if (!wxPyCheckForApp()) SWIG_fail;
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6881
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj;
6894 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6895 PyObject * obj0 = 0 ;
6896 char *kwnames[] = {
6897 (char *) "self", NULL
6898 };
6899
6900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6902 if (SWIG_arg_fail(1)) SWIG_fail;
6903 {
6904 PyThreadState* __tstate = wxPyBeginAllowThreads();
6905 delete arg1;
6906
6907 wxPyEndAllowThreads(__tstate);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 Py_INCREF(Py_None); resultobj = Py_None;
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6918 PyObject *obj;
6919 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6920 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6921 Py_INCREF(obj);
6922 return Py_BuildValue((char *)"");
6923 }
6924 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj;
6926 wxWindow *arg1 = (wxWindow *) NULL ;
6927 wxWindowDisabler *result;
6928 PyObject * obj0 = 0 ;
6929 char *kwnames[] = {
6930 (char *) "winToSkip", NULL
6931 };
6932
6933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6934 if (obj0) {
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 }
6938 {
6939 if (!wxPyCheckForApp()) SWIG_fail;
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6947 return resultobj;
6948 fail:
6949 return NULL;
6950 }
6951
6952
6953 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6954 PyObject *resultobj;
6955 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6956 PyObject * obj0 = 0 ;
6957 char *kwnames[] = {
6958 (char *) "self", NULL
6959 };
6960
6961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6963 if (SWIG_arg_fail(1)) SWIG_fail;
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 delete arg1;
6967
6968 wxPyEndAllowThreads(__tstate);
6969 if (PyErr_Occurred()) SWIG_fail;
6970 }
6971 Py_INCREF(Py_None); resultobj = Py_None;
6972 return resultobj;
6973 fail:
6974 return NULL;
6975 }
6976
6977
6978 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6979 PyObject *obj;
6980 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6981 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6982 Py_INCREF(obj);
6983 return Py_BuildValue((char *)"");
6984 }
6985 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6986 PyObject *resultobj;
6987 wxString *arg1 = 0 ;
6988 wxBusyInfo *result;
6989 bool temp1 = false ;
6990 PyObject * obj0 = 0 ;
6991 char *kwnames[] = {
6992 (char *) "message", NULL
6993 };
6994
6995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
6996 {
6997 arg1 = wxString_in_helper(obj0);
6998 if (arg1 == NULL) SWIG_fail;
6999 temp1 = true;
7000 }
7001 {
7002 if (!wxPyCheckForApp()) SWIG_fail;
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7005
7006 wxPyEndAllowThreads(__tstate);
7007 if (PyErr_Occurred()) SWIG_fail;
7008 }
7009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7010 {
7011 if (temp1)
7012 delete arg1;
7013 }
7014 return resultobj;
7015 fail:
7016 {
7017 if (temp1)
7018 delete arg1;
7019 }
7020 return NULL;
7021 }
7022
7023
7024 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7025 PyObject *resultobj;
7026 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7027 PyObject * obj0 = 0 ;
7028 char *kwnames[] = {
7029 (char *) "self", NULL
7030 };
7031
7032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7034 if (SWIG_arg_fail(1)) SWIG_fail;
7035 {
7036 PyThreadState* __tstate = wxPyBeginAllowThreads();
7037 delete arg1;
7038
7039 wxPyEndAllowThreads(__tstate);
7040 if (PyErr_Occurred()) SWIG_fail;
7041 }
7042 Py_INCREF(Py_None); resultobj = Py_None;
7043 return resultobj;
7044 fail:
7045 return NULL;
7046 }
7047
7048
7049 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7050 PyObject *obj;
7051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7052 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7053 Py_INCREF(obj);
7054 return Py_BuildValue((char *)"");
7055 }
7056 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7057 PyObject *resultobj;
7058 wxStopWatch *result;
7059 char *kwnames[] = {
7060 NULL
7061 };
7062
7063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7064 {
7065 PyThreadState* __tstate = wxPyBeginAllowThreads();
7066 result = (wxStopWatch *)new wxStopWatch();
7067
7068 wxPyEndAllowThreads(__tstate);
7069 if (PyErr_Occurred()) SWIG_fail;
7070 }
7071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7072 return resultobj;
7073 fail:
7074 return NULL;
7075 }
7076
7077
7078 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7079 PyObject *resultobj;
7080 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7081 long arg2 = (long) 0 ;
7082 PyObject * obj0 = 0 ;
7083 PyObject * obj1 = 0 ;
7084 char *kwnames[] = {
7085 (char *) "self",(char *) "t0", NULL
7086 };
7087
7088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7090 if (SWIG_arg_fail(1)) SWIG_fail;
7091 if (obj1) {
7092 {
7093 arg2 = (long)(SWIG_As_long(obj1));
7094 if (SWIG_arg_fail(2)) SWIG_fail;
7095 }
7096 }
7097 {
7098 PyThreadState* __tstate = wxPyBeginAllowThreads();
7099 (arg1)->Start(arg2);
7100
7101 wxPyEndAllowThreads(__tstate);
7102 if (PyErr_Occurred()) SWIG_fail;
7103 }
7104 Py_INCREF(Py_None); resultobj = Py_None;
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj;
7113 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7114 PyObject * obj0 = 0 ;
7115 char *kwnames[] = {
7116 (char *) "self", NULL
7117 };
7118
7119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7121 if (SWIG_arg_fail(1)) SWIG_fail;
7122 {
7123 PyThreadState* __tstate = wxPyBeginAllowThreads();
7124 (arg1)->Pause();
7125
7126 wxPyEndAllowThreads(__tstate);
7127 if (PyErr_Occurred()) SWIG_fail;
7128 }
7129 Py_INCREF(Py_None); resultobj = Py_None;
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj;
7138 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7139 PyObject * obj0 = 0 ;
7140 char *kwnames[] = {
7141 (char *) "self", NULL
7142 };
7143
7144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7146 if (SWIG_arg_fail(1)) SWIG_fail;
7147 {
7148 PyThreadState* __tstate = wxPyBeginAllowThreads();
7149 (arg1)->Resume();
7150
7151 wxPyEndAllowThreads(__tstate);
7152 if (PyErr_Occurred()) SWIG_fail;
7153 }
7154 Py_INCREF(Py_None); resultobj = Py_None;
7155 return resultobj;
7156 fail:
7157 return NULL;
7158 }
7159
7160
7161 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7162 PyObject *resultobj;
7163 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7164 long result;
7165 PyObject * obj0 = 0 ;
7166 char *kwnames[] = {
7167 (char *) "self", NULL
7168 };
7169
7170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7172 if (SWIG_arg_fail(1)) SWIG_fail;
7173 {
7174 PyThreadState* __tstate = wxPyBeginAllowThreads();
7175 result = (long)((wxStopWatch const *)arg1)->Time();
7176
7177 wxPyEndAllowThreads(__tstate);
7178 if (PyErr_Occurred()) SWIG_fail;
7179 }
7180 {
7181 resultobj = SWIG_From_long((long)(result));
7182 }
7183 return resultobj;
7184 fail:
7185 return NULL;
7186 }
7187
7188
7189 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7190 PyObject *obj;
7191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7192 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7193 Py_INCREF(obj);
7194 return Py_BuildValue((char *)"");
7195 }
7196 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7197 PyObject *resultobj;
7198 int arg1 = (int) 9 ;
7199 int arg2 = (int) wxID_FILE1 ;
7200 wxFileHistory *result;
7201 PyObject * obj0 = 0 ;
7202 PyObject * obj1 = 0 ;
7203 char *kwnames[] = {
7204 (char *) "maxFiles",(char *) "idBase", NULL
7205 };
7206
7207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7208 if (obj0) {
7209 {
7210 arg1 = (int)(SWIG_As_int(obj0));
7211 if (SWIG_arg_fail(1)) SWIG_fail;
7212 }
7213 }
7214 if (obj1) {
7215 {
7216 arg2 = (int)(SWIG_As_int(obj1));
7217 if (SWIG_arg_fail(2)) SWIG_fail;
7218 }
7219 }
7220 {
7221 PyThreadState* __tstate = wxPyBeginAllowThreads();
7222 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7223
7224 wxPyEndAllowThreads(__tstate);
7225 if (PyErr_Occurred()) SWIG_fail;
7226 }
7227 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7228 return resultobj;
7229 fail:
7230 return NULL;
7231 }
7232
7233
7234 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7235 PyObject *resultobj;
7236 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7237 PyObject * obj0 = 0 ;
7238 char *kwnames[] = {
7239 (char *) "self", NULL
7240 };
7241
7242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7244 if (SWIG_arg_fail(1)) SWIG_fail;
7245 {
7246 PyThreadState* __tstate = wxPyBeginAllowThreads();
7247 delete arg1;
7248
7249 wxPyEndAllowThreads(__tstate);
7250 if (PyErr_Occurred()) SWIG_fail;
7251 }
7252 Py_INCREF(Py_None); resultobj = Py_None;
7253 return resultobj;
7254 fail:
7255 return NULL;
7256 }
7257
7258
7259 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7260 PyObject *resultobj;
7261 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7262 wxString *arg2 = 0 ;
7263 bool temp2 = false ;
7264 PyObject * obj0 = 0 ;
7265 PyObject * obj1 = 0 ;
7266 char *kwnames[] = {
7267 (char *) "self",(char *) "file", NULL
7268 };
7269
7270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7272 if (SWIG_arg_fail(1)) SWIG_fail;
7273 {
7274 arg2 = wxString_in_helper(obj1);
7275 if (arg2 == NULL) SWIG_fail;
7276 temp2 = true;
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 (arg1)->AddFileToHistory((wxString const &)*arg2);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 {
7287 if (temp2)
7288 delete arg2;
7289 }
7290 return resultobj;
7291 fail:
7292 {
7293 if (temp2)
7294 delete arg2;
7295 }
7296 return NULL;
7297 }
7298
7299
7300 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7301 PyObject *resultobj;
7302 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7303 int arg2 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char *kwnames[] = {
7307 (char *) "self",(char *) "i", NULL
7308 };
7309
7310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7312 if (SWIG_arg_fail(1)) SWIG_fail;
7313 {
7314 arg2 = (int)(SWIG_As_int(obj1));
7315 if (SWIG_arg_fail(2)) SWIG_fail;
7316 }
7317 {
7318 PyThreadState* __tstate = wxPyBeginAllowThreads();
7319 (arg1)->RemoveFileFromHistory(arg2);
7320
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 Py_INCREF(Py_None); resultobj = Py_None;
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj;
7333 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7334 int result;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 {
7351 resultobj = SWIG_From_int((int)(result));
7352 }
7353 return resultobj;
7354 fail:
7355 return NULL;
7356 }
7357
7358
7359 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7360 PyObject *resultobj;
7361 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7362 wxMenu *arg2 = (wxMenu *) 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 char *kwnames[] = {
7366 (char *) "self",(char *) "menu", NULL
7367 };
7368
7369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7371 if (SWIG_arg_fail(1)) SWIG_fail;
7372 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7373 if (SWIG_arg_fail(2)) SWIG_fail;
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 (arg1)->UseMenu(arg2);
7377
7378 wxPyEndAllowThreads(__tstate);
7379 if (PyErr_Occurred()) SWIG_fail;
7380 }
7381 Py_INCREF(Py_None); resultobj = Py_None;
7382 return resultobj;
7383 fail:
7384 return NULL;
7385 }
7386
7387
7388 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7389 PyObject *resultobj;
7390 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7391 wxMenu *arg2 = (wxMenu *) 0 ;
7392 PyObject * obj0 = 0 ;
7393 PyObject * obj1 = 0 ;
7394 char *kwnames[] = {
7395 (char *) "self",(char *) "menu", NULL
7396 };
7397
7398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7400 if (SWIG_arg_fail(1)) SWIG_fail;
7401 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7402 if (SWIG_arg_fail(2)) SWIG_fail;
7403 {
7404 PyThreadState* __tstate = wxPyBeginAllowThreads();
7405 (arg1)->RemoveMenu(arg2);
7406
7407 wxPyEndAllowThreads(__tstate);
7408 if (PyErr_Occurred()) SWIG_fail;
7409 }
7410 Py_INCREF(Py_None); resultobj = Py_None;
7411 return resultobj;
7412 fail:
7413 return NULL;
7414 }
7415
7416
7417 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7418 PyObject *resultobj;
7419 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7420 wxConfigBase *arg2 = 0 ;
7421 PyObject * obj0 = 0 ;
7422 PyObject * obj1 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self",(char *) "config", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7432 if (SWIG_arg_fail(2)) SWIG_fail;
7433 if (arg2 == NULL) {
7434 SWIG_null_ref("wxConfigBase");
7435 }
7436 if (SWIG_arg_fail(2)) SWIG_fail;
7437 }
7438 {
7439 PyThreadState* __tstate = wxPyBeginAllowThreads();
7440 (arg1)->Load(*arg2);
7441
7442 wxPyEndAllowThreads(__tstate);
7443 if (PyErr_Occurred()) SWIG_fail;
7444 }
7445 Py_INCREF(Py_None); resultobj = Py_None;
7446 return resultobj;
7447 fail:
7448 return NULL;
7449 }
7450
7451
7452 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7453 PyObject *resultobj;
7454 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7455 wxConfigBase *arg2 = 0 ;
7456 PyObject * obj0 = 0 ;
7457 PyObject * obj1 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self",(char *) "config", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7467 if (SWIG_arg_fail(2)) SWIG_fail;
7468 if (arg2 == NULL) {
7469 SWIG_null_ref("wxConfigBase");
7470 }
7471 if (SWIG_arg_fail(2)) SWIG_fail;
7472 }
7473 {
7474 PyThreadState* __tstate = wxPyBeginAllowThreads();
7475 (arg1)->Save(*arg2);
7476
7477 wxPyEndAllowThreads(__tstate);
7478 if (PyErr_Occurred()) SWIG_fail;
7479 }
7480 Py_INCREF(Py_None); resultobj = Py_None;
7481 return resultobj;
7482 fail:
7483 return NULL;
7484 }
7485
7486
7487 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7488 PyObject *resultobj;
7489 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7490 PyObject * obj0 = 0 ;
7491 char *kwnames[] = {
7492 (char *) "self", NULL
7493 };
7494
7495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7497 if (SWIG_arg_fail(1)) SWIG_fail;
7498 {
7499 PyThreadState* __tstate = wxPyBeginAllowThreads();
7500 (arg1)->AddFilesToMenu();
7501
7502 wxPyEndAllowThreads(__tstate);
7503 if (PyErr_Occurred()) SWIG_fail;
7504 }
7505 Py_INCREF(Py_None); resultobj = Py_None;
7506 return resultobj;
7507 fail:
7508 return NULL;
7509 }
7510
7511
7512 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj;
7514 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7515 wxMenu *arg2 = (wxMenu *) 0 ;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char *kwnames[] = {
7519 (char *) "self",(char *) "menu", NULL
7520 };
7521
7522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7524 if (SWIG_arg_fail(1)) SWIG_fail;
7525 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7526 if (SWIG_arg_fail(2)) SWIG_fail;
7527 {
7528 PyThreadState* __tstate = wxPyBeginAllowThreads();
7529 (arg1)->AddFilesToMenu(arg2);
7530
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 Py_INCREF(Py_None); resultobj = Py_None;
7535 return resultobj;
7536 fail:
7537 return NULL;
7538 }
7539
7540
7541 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7542 PyObject *resultobj;
7543 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7544 int arg2 ;
7545 wxString result;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char *kwnames[] = {
7549 (char *) "self",(char *) "i", NULL
7550 };
7551
7552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7554 if (SWIG_arg_fail(1)) SWIG_fail;
7555 {
7556 arg2 = (int)(SWIG_As_int(obj1));
7557 if (SWIG_arg_fail(2)) SWIG_fail;
7558 }
7559 {
7560 PyThreadState* __tstate = wxPyBeginAllowThreads();
7561 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7562
7563 wxPyEndAllowThreads(__tstate);
7564 if (PyErr_Occurred()) SWIG_fail;
7565 }
7566 {
7567 #if wxUSE_UNICODE
7568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7569 #else
7570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7571 #endif
7572 }
7573 return resultobj;
7574 fail:
7575 return NULL;
7576 }
7577
7578
7579 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7580 PyObject *resultobj;
7581 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7582 int result;
7583 PyObject * obj0 = 0 ;
7584 char *kwnames[] = {
7585 (char *) "self", NULL
7586 };
7587
7588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7590 if (SWIG_arg_fail(1)) SWIG_fail;
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (int)((wxFileHistory const *)arg1)->GetCount();
7594
7595 wxPyEndAllowThreads(__tstate);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = SWIG_From_int((int)(result));
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7608 PyObject *obj;
7609 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7610 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7611 Py_INCREF(obj);
7612 return Py_BuildValue((char *)"");
7613 }
7614 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7615 PyObject *resultobj;
7616 wxString *arg1 = 0 ;
7617 wxString const &arg2_defvalue = wxPyEmptyString ;
7618 wxString *arg2 = (wxString *) &arg2_defvalue ;
7619 wxSingleInstanceChecker *result;
7620 bool temp1 = false ;
7621 bool temp2 = false ;
7622 PyObject * obj0 = 0 ;
7623 PyObject * obj1 = 0 ;
7624 char *kwnames[] = {
7625 (char *) "name",(char *) "path", NULL
7626 };
7627
7628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7629 {
7630 arg1 = wxString_in_helper(obj0);
7631 if (arg1 == NULL) SWIG_fail;
7632 temp1 = true;
7633 }
7634 if (obj1) {
7635 {
7636 arg2 = wxString_in_helper(obj1);
7637 if (arg2 == NULL) SWIG_fail;
7638 temp2 = true;
7639 }
7640 }
7641 {
7642 PyThreadState* __tstate = wxPyBeginAllowThreads();
7643 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7644
7645 wxPyEndAllowThreads(__tstate);
7646 if (PyErr_Occurred()) SWIG_fail;
7647 }
7648 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7649 {
7650 if (temp1)
7651 delete arg1;
7652 }
7653 {
7654 if (temp2)
7655 delete arg2;
7656 }
7657 return resultobj;
7658 fail:
7659 {
7660 if (temp1)
7661 delete arg1;
7662 }
7663 {
7664 if (temp2)
7665 delete arg2;
7666 }
7667 return NULL;
7668 }
7669
7670
7671 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj;
7673 wxSingleInstanceChecker *result;
7674 char *kwnames[] = {
7675 NULL
7676 };
7677
7678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7679 {
7680 PyThreadState* __tstate = wxPyBeginAllowThreads();
7681 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7682
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7694 PyObject *resultobj;
7695 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7696 PyObject * obj0 = 0 ;
7697 char *kwnames[] = {
7698 (char *) "self", NULL
7699 };
7700
7701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7703 if (SWIG_arg_fail(1)) SWIG_fail;
7704 {
7705 PyThreadState* __tstate = wxPyBeginAllowThreads();
7706 delete arg1;
7707
7708 wxPyEndAllowThreads(__tstate);
7709 if (PyErr_Occurred()) SWIG_fail;
7710 }
7711 Py_INCREF(Py_None); resultobj = Py_None;
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj;
7720 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7721 wxString *arg2 = 0 ;
7722 wxString const &arg3_defvalue = wxPyEmptyString ;
7723 wxString *arg3 = (wxString *) &arg3_defvalue ;
7724 bool result;
7725 bool temp2 = false ;
7726 bool temp3 = false ;
7727 PyObject * obj0 = 0 ;
7728 PyObject * obj1 = 0 ;
7729 PyObject * obj2 = 0 ;
7730 char *kwnames[] = {
7731 (char *) "self",(char *) "name",(char *) "path", NULL
7732 };
7733
7734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7736 if (SWIG_arg_fail(1)) SWIG_fail;
7737 {
7738 arg2 = wxString_in_helper(obj1);
7739 if (arg2 == NULL) SWIG_fail;
7740 temp2 = true;
7741 }
7742 if (obj2) {
7743 {
7744 arg3 = wxString_in_helper(obj2);
7745 if (arg3 == NULL) SWIG_fail;
7746 temp3 = true;
7747 }
7748 }
7749 {
7750 PyThreadState* __tstate = wxPyBeginAllowThreads();
7751 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7752
7753 wxPyEndAllowThreads(__tstate);
7754 if (PyErr_Occurred()) SWIG_fail;
7755 }
7756 {
7757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7758 }
7759 {
7760 if (temp2)
7761 delete arg2;
7762 }
7763 {
7764 if (temp3)
7765 delete arg3;
7766 }
7767 return resultobj;
7768 fail:
7769 {
7770 if (temp2)
7771 delete arg2;
7772 }
7773 {
7774 if (temp3)
7775 delete arg3;
7776 }
7777 return NULL;
7778 }
7779
7780
7781 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj;
7783 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7784 bool result;
7785 PyObject * obj0 = 0 ;
7786 char *kwnames[] = {
7787 (char *) "self", NULL
7788 };
7789
7790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7792 if (SWIG_arg_fail(1)) SWIG_fail;
7793 {
7794 PyThreadState* __tstate = wxPyBeginAllowThreads();
7795 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7796
7797 wxPyEndAllowThreads(__tstate);
7798 if (PyErr_Occurred()) SWIG_fail;
7799 }
7800 {
7801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7802 }
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7810 PyObject *obj;
7811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7812 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7813 Py_INCREF(obj);
7814 return Py_BuildValue((char *)"");
7815 }
7816 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7817 PyObject *resultobj;
7818 wxWindow *arg1 = (wxWindow *) 0 ;
7819 wxDC *arg2 = 0 ;
7820 bool result;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char *kwnames[] = {
7824 (char *) "window",(char *) "dc", NULL
7825 };
7826
7827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7829 if (SWIG_arg_fail(1)) SWIG_fail;
7830 {
7831 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7832 if (SWIG_arg_fail(2)) SWIG_fail;
7833 if (arg2 == NULL) {
7834 SWIG_null_ref("wxDC");
7835 }
7836 if (SWIG_arg_fail(2)) SWIG_fail;
7837 }
7838 {
7839 PyThreadState* __tstate = wxPyBeginAllowThreads();
7840 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7841
7842 wxPyEndAllowThreads(__tstate);
7843 if (PyErr_Occurred()) SWIG_fail;
7844 }
7845 {
7846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7847 }
7848 return resultobj;
7849 fail:
7850 return NULL;
7851 }
7852
7853
7854 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7855 PyObject *resultobj;
7856 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7857 PyObject * obj0 = 0 ;
7858 char *kwnames[] = {
7859 (char *) "self", NULL
7860 };
7861
7862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7864 if (SWIG_arg_fail(1)) SWIG_fail;
7865 {
7866 PyThreadState* __tstate = wxPyBeginAllowThreads();
7867 delete arg1;
7868
7869 wxPyEndAllowThreads(__tstate);
7870 if (PyErr_Occurred()) SWIG_fail;
7871 }
7872 Py_INCREF(Py_None); resultobj = Py_None;
7873 return resultobj;
7874 fail:
7875 return NULL;
7876 }
7877
7878
7879 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7880 PyObject *resultobj;
7881 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7882 wxString result;
7883 PyObject * obj0 = 0 ;
7884 char *kwnames[] = {
7885 (char *) "self", NULL
7886 };
7887
7888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7890 if (SWIG_arg_fail(1)) SWIG_fail;
7891 {
7892 PyThreadState* __tstate = wxPyBeginAllowThreads();
7893 result = (arg1)->GetTip();
7894
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 {
7899 #if wxUSE_UNICODE
7900 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7901 #else
7902 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7903 #endif
7904 }
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj;
7913 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7914 size_t result;
7915 PyObject * obj0 = 0 ;
7916 char *kwnames[] = {
7917 (char *) "self", NULL
7918 };
7919
7920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7922 if (SWIG_arg_fail(1)) SWIG_fail;
7923 {
7924 PyThreadState* __tstate = wxPyBeginAllowThreads();
7925 result = (size_t)(arg1)->GetCurrentTip();
7926
7927 wxPyEndAllowThreads(__tstate);
7928 if (PyErr_Occurred()) SWIG_fail;
7929 }
7930 {
7931 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7932 }
7933 return resultobj;
7934 fail:
7935 return NULL;
7936 }
7937
7938
7939 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7940 PyObject *resultobj;
7941 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7942 wxString *arg2 = 0 ;
7943 wxString result;
7944 bool temp2 = false ;
7945 PyObject * obj0 = 0 ;
7946 PyObject * obj1 = 0 ;
7947 char *kwnames[] = {
7948 (char *) "self",(char *) "tip", NULL
7949 };
7950
7951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7953 if (SWIG_arg_fail(1)) SWIG_fail;
7954 {
7955 arg2 = wxString_in_helper(obj1);
7956 if (arg2 == NULL) SWIG_fail;
7957 temp2 = true;
7958 }
7959 {
7960 PyThreadState* __tstate = wxPyBeginAllowThreads();
7961 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7962
7963 wxPyEndAllowThreads(__tstate);
7964 if (PyErr_Occurred()) SWIG_fail;
7965 }
7966 {
7967 #if wxUSE_UNICODE
7968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7969 #else
7970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7971 #endif
7972 }
7973 {
7974 if (temp2)
7975 delete arg2;
7976 }
7977 return resultobj;
7978 fail:
7979 {
7980 if (temp2)
7981 delete arg2;
7982 }
7983 return NULL;
7984 }
7985
7986
7987 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7988 PyObject *obj;
7989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7990 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
7991 Py_INCREF(obj);
7992 return Py_BuildValue((char *)"");
7993 }
7994 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7995 PyObject *resultobj;
7996 size_t arg1 ;
7997 wxPyTipProvider *result;
7998 PyObject * obj0 = 0 ;
7999 char *kwnames[] = {
8000 (char *) "currentTip", NULL
8001 };
8002
8003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8004 {
8005 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8006 if (SWIG_arg_fail(1)) SWIG_fail;
8007 }
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8011
8012 wxPyEndAllowThreads(__tstate);
8013 if (PyErr_Occurred()) SWIG_fail;
8014 }
8015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8016 return resultobj;
8017 fail:
8018 return NULL;
8019 }
8020
8021
8022 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8023 PyObject *resultobj;
8024 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8025 PyObject *arg2 = (PyObject *) 0 ;
8026 PyObject *arg3 = (PyObject *) 0 ;
8027 PyObject * obj0 = 0 ;
8028 PyObject * obj1 = 0 ;
8029 PyObject * obj2 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self",(char *) "self",(char *) "_class", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 arg2 = obj1;
8038 arg3 = obj2;
8039 {
8040 PyThreadState* __tstate = wxPyBeginAllowThreads();
8041 (arg1)->_setCallbackInfo(arg2,arg3);
8042
8043 wxPyEndAllowThreads(__tstate);
8044 if (PyErr_Occurred()) SWIG_fail;
8045 }
8046 Py_INCREF(Py_None); resultobj = Py_None;
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8054 PyObject *obj;
8055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8056 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8057 Py_INCREF(obj);
8058 return Py_BuildValue((char *)"");
8059 }
8060 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 wxWindow *arg1 = (wxWindow *) 0 ;
8063 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8064 bool arg3 = (bool) true ;
8065 bool result;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 PyObject * obj2 = 0 ;
8069 char *kwnames[] = {
8070 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8071 };
8072
8073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8075 if (SWIG_arg_fail(1)) SWIG_fail;
8076 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8077 if (SWIG_arg_fail(2)) SWIG_fail;
8078 if (obj2) {
8079 {
8080 arg3 = (bool)(SWIG_As_bool(obj2));
8081 if (SWIG_arg_fail(3)) SWIG_fail;
8082 }
8083 }
8084 {
8085 if (!wxPyCheckForApp()) SWIG_fail;
8086 PyThreadState* __tstate = wxPyBeginAllowThreads();
8087 result = (bool)wxShowTip(arg1,arg2,arg3);
8088
8089 wxPyEndAllowThreads(__tstate);
8090 if (PyErr_Occurred()) SWIG_fail;
8091 }
8092 {
8093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8094 }
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8102 PyObject *resultobj;
8103 wxString *arg1 = 0 ;
8104 size_t arg2 ;
8105 wxTipProvider *result;
8106 bool temp1 = false ;
8107 PyObject * obj0 = 0 ;
8108 PyObject * obj1 = 0 ;
8109 char *kwnames[] = {
8110 (char *) "filename",(char *) "currentTip", NULL
8111 };
8112
8113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8114 {
8115 arg1 = wxString_in_helper(obj0);
8116 if (arg1 == NULL) SWIG_fail;
8117 temp1 = true;
8118 }
8119 {
8120 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8121 if (SWIG_arg_fail(2)) SWIG_fail;
8122 }
8123 {
8124 if (!wxPyCheckForApp()) SWIG_fail;
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8132 {
8133 if (temp1)
8134 delete arg1;
8135 }
8136 return resultobj;
8137 fail:
8138 {
8139 if (temp1)
8140 delete arg1;
8141 }
8142 return NULL;
8143 }
8144
8145
8146 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8147 PyObject *resultobj;
8148 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8149 int arg2 = (int) -1 ;
8150 wxPyTimer *result;
8151 PyObject * obj0 = 0 ;
8152 PyObject * obj1 = 0 ;
8153 char *kwnames[] = {
8154 (char *) "owner",(char *) "id", NULL
8155 };
8156
8157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8158 if (obj0) {
8159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8160 if (SWIG_arg_fail(1)) SWIG_fail;
8161 }
8162 if (obj1) {
8163 {
8164 arg2 = (int)(SWIG_As_int(obj1));
8165 if (SWIG_arg_fail(2)) SWIG_fail;
8166 }
8167 }
8168 {
8169 if (!wxPyCheckForApp()) SWIG_fail;
8170 PyThreadState* __tstate = wxPyBeginAllowThreads();
8171 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8172
8173 wxPyEndAllowThreads(__tstate);
8174 if (PyErr_Occurred()) SWIG_fail;
8175 }
8176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8177 return resultobj;
8178 fail:
8179 return NULL;
8180 }
8181
8182
8183 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8184 PyObject *resultobj;
8185 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8186 PyObject * obj0 = 0 ;
8187 char *kwnames[] = {
8188 (char *) "self", NULL
8189 };
8190
8191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8193 if (SWIG_arg_fail(1)) SWIG_fail;
8194 {
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 delete arg1;
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 Py_INCREF(Py_None); resultobj = Py_None;
8202 return resultobj;
8203 fail:
8204 return NULL;
8205 }
8206
8207
8208 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8209 PyObject *resultobj;
8210 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8211 PyObject *arg2 = (PyObject *) 0 ;
8212 PyObject *arg3 = (PyObject *) 0 ;
8213 int arg4 = (int) 1 ;
8214 PyObject * obj0 = 0 ;
8215 PyObject * obj1 = 0 ;
8216 PyObject * obj2 = 0 ;
8217 PyObject * obj3 = 0 ;
8218 char *kwnames[] = {
8219 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8220 };
8221
8222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8224 if (SWIG_arg_fail(1)) SWIG_fail;
8225 arg2 = obj1;
8226 arg3 = obj2;
8227 if (obj3) {
8228 {
8229 arg4 = (int)(SWIG_As_int(obj3));
8230 if (SWIG_arg_fail(4)) SWIG_fail;
8231 }
8232 }
8233 {
8234 PyThreadState* __tstate = wxPyBeginAllowThreads();
8235 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8236
8237 wxPyEndAllowThreads(__tstate);
8238 if (PyErr_Occurred()) SWIG_fail;
8239 }
8240 Py_INCREF(Py_None); resultobj = Py_None;
8241 return resultobj;
8242 fail:
8243 return NULL;
8244 }
8245
8246
8247 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8248 PyObject *resultobj;
8249 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8250 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8251 int arg3 = (int) -1 ;
8252 PyObject * obj0 = 0 ;
8253 PyObject * obj1 = 0 ;
8254 PyObject * obj2 = 0 ;
8255 char *kwnames[] = {
8256 (char *) "self",(char *) "owner",(char *) "id", NULL
8257 };
8258
8259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8261 if (SWIG_arg_fail(1)) SWIG_fail;
8262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8263 if (SWIG_arg_fail(2)) SWIG_fail;
8264 if (obj2) {
8265 {
8266 arg3 = (int)(SWIG_As_int(obj2));
8267 if (SWIG_arg_fail(3)) SWIG_fail;
8268 }
8269 }
8270 {
8271 PyThreadState* __tstate = wxPyBeginAllowThreads();
8272 (arg1)->SetOwner(arg2,arg3);
8273
8274 wxPyEndAllowThreads(__tstate);
8275 if (PyErr_Occurred()) SWIG_fail;
8276 }
8277 Py_INCREF(Py_None); resultobj = Py_None;
8278 return resultobj;
8279 fail:
8280 return NULL;
8281 }
8282
8283
8284 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8285 PyObject *resultobj;
8286 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8287 wxEvtHandler *result;
8288 PyObject * obj0 = 0 ;
8289 char *kwnames[] = {
8290 (char *) "self", NULL
8291 };
8292
8293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8295 if (SWIG_arg_fail(1)) SWIG_fail;
8296 {
8297 PyThreadState* __tstate = wxPyBeginAllowThreads();
8298 result = (wxEvtHandler *)(arg1)->GetOwner();
8299
8300 wxPyEndAllowThreads(__tstate);
8301 if (PyErr_Occurred()) SWIG_fail;
8302 }
8303 {
8304 resultobj = wxPyMake_wxObject(result, 0);
8305 }
8306 return resultobj;
8307 fail:
8308 return NULL;
8309 }
8310
8311
8312 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8313 PyObject *resultobj;
8314 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8315 int arg2 = (int) -1 ;
8316 bool arg3 = (bool) false ;
8317 bool result;
8318 PyObject * obj0 = 0 ;
8319 PyObject * obj1 = 0 ;
8320 PyObject * obj2 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 if (obj1) {
8329 {
8330 arg2 = (int)(SWIG_As_int(obj1));
8331 if (SWIG_arg_fail(2)) SWIG_fail;
8332 }
8333 }
8334 if (obj2) {
8335 {
8336 arg3 = (bool)(SWIG_As_bool(obj2));
8337 if (SWIG_arg_fail(3)) SWIG_fail;
8338 }
8339 }
8340 {
8341 PyThreadState* __tstate = wxPyBeginAllowThreads();
8342 result = (bool)(arg1)->Start(arg2,arg3);
8343
8344 wxPyEndAllowThreads(__tstate);
8345 if (PyErr_Occurred()) SWIG_fail;
8346 }
8347 {
8348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8349 }
8350 return resultobj;
8351 fail:
8352 return NULL;
8353 }
8354
8355
8356 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8357 PyObject *resultobj;
8358 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8359 PyObject * obj0 = 0 ;
8360 char *kwnames[] = {
8361 (char *) "self", NULL
8362 };
8363
8364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8366 if (SWIG_arg_fail(1)) SWIG_fail;
8367 {
8368 PyThreadState* __tstate = wxPyBeginAllowThreads();
8369 (arg1)->Stop();
8370
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 Py_INCREF(Py_None); resultobj = Py_None;
8375 return resultobj;
8376 fail:
8377 return NULL;
8378 }
8379
8380
8381 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8382 PyObject *resultobj;
8383 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8384 bool result;
8385 PyObject * obj0 = 0 ;
8386 char *kwnames[] = {
8387 (char *) "self", NULL
8388 };
8389
8390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8392 if (SWIG_arg_fail(1)) SWIG_fail;
8393 {
8394 PyThreadState* __tstate = wxPyBeginAllowThreads();
8395 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8396
8397 wxPyEndAllowThreads(__tstate);
8398 if (PyErr_Occurred()) SWIG_fail;
8399 }
8400 {
8401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8402 }
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8412 int result;
8413 PyObject * obj0 = 0 ;
8414 char *kwnames[] = {
8415 (char *) "self", NULL
8416 };
8417
8418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8420 if (SWIG_arg_fail(1)) SWIG_fail;
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 resultobj = SWIG_From_int((int)(result));
8430 }
8431 return resultobj;
8432 fail:
8433 return NULL;
8434 }
8435
8436
8437 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8438 PyObject *resultobj;
8439 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8440 bool result;
8441 PyObject * obj0 = 0 ;
8442 char *kwnames[] = {
8443 (char *) "self", NULL
8444 };
8445
8446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8448 if (SWIG_arg_fail(1)) SWIG_fail;
8449 {
8450 PyThreadState* __tstate = wxPyBeginAllowThreads();
8451 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8452
8453 wxPyEndAllowThreads(__tstate);
8454 if (PyErr_Occurred()) SWIG_fail;
8455 }
8456 {
8457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8458 }
8459 return resultobj;
8460 fail:
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8468 int result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (int)((wxPyTimer const *)arg1)->GetId();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 resultobj = SWIG_From_int((int)(result));
8486 }
8487 return resultobj;
8488 fail:
8489 return NULL;
8490 }
8491
8492
8493 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8494 PyObject *obj;
8495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8496 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8497 Py_INCREF(obj);
8498 return Py_BuildValue((char *)"");
8499 }
8500 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8501 PyObject *resultobj;
8502 int arg1 = (int) 0 ;
8503 int arg2 = (int) 0 ;
8504 wxTimerEvent *result;
8505 PyObject * obj0 = 0 ;
8506 PyObject * obj1 = 0 ;
8507 char *kwnames[] = {
8508 (char *) "timerid",(char *) "interval", NULL
8509 };
8510
8511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8512 if (obj0) {
8513 {
8514 arg1 = (int)(SWIG_As_int(obj0));
8515 if (SWIG_arg_fail(1)) SWIG_fail;
8516 }
8517 }
8518 if (obj1) {
8519 {
8520 arg2 = (int)(SWIG_As_int(obj1));
8521 if (SWIG_arg_fail(2)) SWIG_fail;
8522 }
8523 }
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8527
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj;
8540 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8541 int result;
8542 PyObject * obj0 = 0 ;
8543 char *kwnames[] = {
8544 (char *) "self", NULL
8545 };
8546
8547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8549 if (SWIG_arg_fail(1)) SWIG_fail;
8550 {
8551 PyThreadState* __tstate = wxPyBeginAllowThreads();
8552 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8553
8554 wxPyEndAllowThreads(__tstate);
8555 if (PyErr_Occurred()) SWIG_fail;
8556 }
8557 {
8558 resultobj = SWIG_From_int((int)(result));
8559 }
8560 return resultobj;
8561 fail:
8562 return NULL;
8563 }
8564
8565
8566 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8567 PyObject *obj;
8568 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8569 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8570 Py_INCREF(obj);
8571 return Py_BuildValue((char *)"");
8572 }
8573 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8574 PyObject *resultobj;
8575 wxTimer *arg1 = 0 ;
8576 wxTimerRunner *result;
8577 PyObject * obj0 = 0 ;
8578
8579 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8580 {
8581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8582 if (SWIG_arg_fail(1)) SWIG_fail;
8583 if (arg1 == NULL) {
8584 SWIG_null_ref("wxTimer");
8585 }
8586 if (SWIG_arg_fail(1)) SWIG_fail;
8587 }
8588 {
8589 if (!wxPyCheckForApp()) SWIG_fail;
8590 PyThreadState* __tstate = wxPyBeginAllowThreads();
8591 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8592
8593 wxPyEndAllowThreads(__tstate);
8594 if (PyErr_Occurred()) SWIG_fail;
8595 }
8596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8597 return resultobj;
8598 fail:
8599 return NULL;
8600 }
8601
8602
8603 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8604 PyObject *resultobj;
8605 wxTimer *arg1 = 0 ;
8606 int arg2 ;
8607 bool arg3 = (bool) false ;
8608 wxTimerRunner *result;
8609 PyObject * obj0 = 0 ;
8610 PyObject * obj1 = 0 ;
8611 PyObject * obj2 = 0 ;
8612
8613 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8614 {
8615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8616 if (SWIG_arg_fail(1)) SWIG_fail;
8617 if (arg1 == NULL) {
8618 SWIG_null_ref("wxTimer");
8619 }
8620 if (SWIG_arg_fail(1)) SWIG_fail;
8621 }
8622 {
8623 arg2 = (int)(SWIG_As_int(obj1));
8624 if (SWIG_arg_fail(2)) SWIG_fail;
8625 }
8626 if (obj2) {
8627 {
8628 arg3 = (bool)(SWIG_As_bool(obj2));
8629 if (SWIG_arg_fail(3)) SWIG_fail;
8630 }
8631 }
8632 {
8633 if (!wxPyCheckForApp()) SWIG_fail;
8634 PyThreadState* __tstate = wxPyBeginAllowThreads();
8635 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8636
8637 wxPyEndAllowThreads(__tstate);
8638 if (PyErr_Occurred()) SWIG_fail;
8639 }
8640 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8641 return resultobj;
8642 fail:
8643 return NULL;
8644 }
8645
8646
8647 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8648 int argc;
8649 PyObject *argv[4];
8650 int ii;
8651
8652 argc = PyObject_Length(args);
8653 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8654 argv[ii] = PyTuple_GetItem(args,ii);
8655 }
8656 if (argc == 1) {
8657 int _v;
8658 {
8659 void *ptr = 0;
8660 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8661 _v = 0;
8662 PyErr_Clear();
8663 } else {
8664 _v = (ptr != 0);
8665 }
8666 }
8667 if (_v) {
8668 return _wrap_new_TimerRunner__SWIG_0(self,args);
8669 }
8670 }
8671 if ((argc >= 2) && (argc <= 3)) {
8672 int _v;
8673 {
8674 void *ptr = 0;
8675 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8676 _v = 0;
8677 PyErr_Clear();
8678 } else {
8679 _v = (ptr != 0);
8680 }
8681 }
8682 if (_v) {
8683 _v = SWIG_Check_int(argv[1]);
8684 if (_v) {
8685 if (argc <= 2) {
8686 return _wrap_new_TimerRunner__SWIG_1(self,args);
8687 }
8688 _v = SWIG_Check_bool(argv[2]);
8689 if (_v) {
8690 return _wrap_new_TimerRunner__SWIG_1(self,args);
8691 }
8692 }
8693 }
8694 }
8695
8696 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8702 PyObject *resultobj;
8703 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8704 PyObject * obj0 = 0 ;
8705 char *kwnames[] = {
8706 (char *) "self", NULL
8707 };
8708
8709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8711 if (SWIG_arg_fail(1)) SWIG_fail;
8712 {
8713 PyThreadState* __tstate = wxPyBeginAllowThreads();
8714 delete arg1;
8715
8716 wxPyEndAllowThreads(__tstate);
8717 if (PyErr_Occurred()) SWIG_fail;
8718 }
8719 Py_INCREF(Py_None); resultobj = Py_None;
8720 return resultobj;
8721 fail:
8722 return NULL;
8723 }
8724
8725
8726 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8727 PyObject *resultobj;
8728 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8729 int arg2 ;
8730 bool arg3 = (bool) false ;
8731 PyObject * obj0 = 0 ;
8732 PyObject * obj1 = 0 ;
8733 PyObject * obj2 = 0 ;
8734 char *kwnames[] = {
8735 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8736 };
8737
8738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8740 if (SWIG_arg_fail(1)) SWIG_fail;
8741 {
8742 arg2 = (int)(SWIG_As_int(obj1));
8743 if (SWIG_arg_fail(2)) SWIG_fail;
8744 }
8745 if (obj2) {
8746 {
8747 arg3 = (bool)(SWIG_As_bool(obj2));
8748 if (SWIG_arg_fail(3)) SWIG_fail;
8749 }
8750 }
8751 {
8752 PyThreadState* __tstate = wxPyBeginAllowThreads();
8753 (arg1)->Start(arg2,arg3);
8754
8755 wxPyEndAllowThreads(__tstate);
8756 if (PyErr_Occurred()) SWIG_fail;
8757 }
8758 Py_INCREF(Py_None); resultobj = Py_None;
8759 return resultobj;
8760 fail:
8761 return NULL;
8762 }
8763
8764
8765 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8766 PyObject *obj;
8767 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8768 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8769 Py_INCREF(obj);
8770 return Py_BuildValue((char *)"");
8771 }
8772 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8773 PyObject *resultobj;
8774 wxLog *result;
8775 char *kwnames[] = {
8776 NULL
8777 };
8778
8779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8780 {
8781 PyThreadState* __tstate = wxPyBeginAllowThreads();
8782 result = (wxLog *)new wxLog();
8783
8784 wxPyEndAllowThreads(__tstate);
8785 if (PyErr_Occurred()) SWIG_fail;
8786 }
8787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8795 PyObject *resultobj;
8796 bool result;
8797 char *kwnames[] = {
8798 NULL
8799 };
8800
8801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8802 {
8803 PyThreadState* __tstate = wxPyBeginAllowThreads();
8804 result = (bool)wxLog::IsEnabled();
8805
8806 wxPyEndAllowThreads(__tstate);
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 {
8810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8811 }
8812 return resultobj;
8813 fail:
8814 return NULL;
8815 }
8816
8817
8818 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8819 PyObject *resultobj;
8820 bool arg1 = (bool) true ;
8821 bool result;
8822 PyObject * obj0 = 0 ;
8823 char *kwnames[] = {
8824 (char *) "doIt", NULL
8825 };
8826
8827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8828 if (obj0) {
8829 {
8830 arg1 = (bool)(SWIG_As_bool(obj0));
8831 if (SWIG_arg_fail(1)) SWIG_fail;
8832 }
8833 }
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 result = (bool)wxLog::EnableLogging(arg1);
8837
8838 wxPyEndAllowThreads(__tstate);
8839 if (PyErr_Occurred()) SWIG_fail;
8840 }
8841 {
8842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8843 }
8844 return resultobj;
8845 fail:
8846 return NULL;
8847 }
8848
8849
8850 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8851 PyObject *resultobj;
8852 wxLogLevel arg1 ;
8853 wxChar *arg2 = (wxChar *) 0 ;
8854 time_t arg3 ;
8855 PyObject * obj0 = 0 ;
8856 PyObject * obj1 = 0 ;
8857 PyObject * obj2 = 0 ;
8858 char *kwnames[] = {
8859 (char *) "level",(char *) "szString",(char *) "t", NULL
8860 };
8861
8862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8863 {
8864 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8865 if (SWIG_arg_fail(1)) SWIG_fail;
8866 }
8867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8868 if (SWIG_arg_fail(2)) SWIG_fail;
8869 {
8870 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8871 if (SWIG_arg_fail(3)) SWIG_fail;
8872 }
8873 {
8874 PyThreadState* __tstate = wxPyBeginAllowThreads();
8875 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8876
8877 wxPyEndAllowThreads(__tstate);
8878 if (PyErr_Occurred()) SWIG_fail;
8879 }
8880 Py_INCREF(Py_None); resultobj = Py_None;
8881 return resultobj;
8882 fail:
8883 return NULL;
8884 }
8885
8886
8887 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8888 PyObject *resultobj;
8889 wxLog *arg1 = (wxLog *) 0 ;
8890 PyObject * obj0 = 0 ;
8891 char *kwnames[] = {
8892 (char *) "self", NULL
8893 };
8894
8895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8897 if (SWIG_arg_fail(1)) SWIG_fail;
8898 {
8899 PyThreadState* __tstate = wxPyBeginAllowThreads();
8900 (arg1)->Flush();
8901
8902 wxPyEndAllowThreads(__tstate);
8903 if (PyErr_Occurred()) SWIG_fail;
8904 }
8905 Py_INCREF(Py_None); resultobj = Py_None;
8906 return resultobj;
8907 fail:
8908 return NULL;
8909 }
8910
8911
8912 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8913 PyObject *resultobj;
8914 char *kwnames[] = {
8915 NULL
8916 };
8917
8918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8919 {
8920 PyThreadState* __tstate = wxPyBeginAllowThreads();
8921 wxLog::FlushActive();
8922
8923 wxPyEndAllowThreads(__tstate);
8924 if (PyErr_Occurred()) SWIG_fail;
8925 }
8926 Py_INCREF(Py_None); resultobj = Py_None;
8927 return resultobj;
8928 fail:
8929 return NULL;
8930 }
8931
8932
8933 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8934 PyObject *resultobj;
8935 wxLog *result;
8936 char *kwnames[] = {
8937 NULL
8938 };
8939
8940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8941 {
8942 PyThreadState* __tstate = wxPyBeginAllowThreads();
8943 result = (wxLog *)wxLog::GetActiveTarget();
8944
8945 wxPyEndAllowThreads(__tstate);
8946 if (PyErr_Occurred()) SWIG_fail;
8947 }
8948 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
8955 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj;
8957 wxLog *arg1 = (wxLog *) 0 ;
8958 wxLog *result;
8959 PyObject * obj0 = 0 ;
8960 char *kwnames[] = {
8961 (char *) "pLogger", NULL
8962 };
8963
8964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8966 if (SWIG_arg_fail(1)) SWIG_fail;
8967 {
8968 PyThreadState* __tstate = wxPyBeginAllowThreads();
8969 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8970
8971 wxPyEndAllowThreads(__tstate);
8972 if (PyErr_Occurred()) SWIG_fail;
8973 }
8974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8975 return resultobj;
8976 fail:
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj;
8983 char *kwnames[] = {
8984 NULL
8985 };
8986
8987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 wxLog::Suspend();
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 Py_INCREF(Py_None); resultobj = Py_None;
8996 return resultobj;
8997 fail:
8998 return NULL;
8999 }
9000
9001
9002 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9003 PyObject *resultobj;
9004 char *kwnames[] = {
9005 NULL
9006 };
9007
9008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9009 {
9010 PyThreadState* __tstate = wxPyBeginAllowThreads();
9011 wxLog::Resume();
9012
9013 wxPyEndAllowThreads(__tstate);
9014 if (PyErr_Occurred()) SWIG_fail;
9015 }
9016 Py_INCREF(Py_None); resultobj = Py_None;
9017 return resultobj;
9018 fail:
9019 return NULL;
9020 }
9021
9022
9023 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9024 PyObject *resultobj;
9025 bool arg1 = (bool) true ;
9026 PyObject * obj0 = 0 ;
9027 char *kwnames[] = {
9028 (char *) "bVerbose", NULL
9029 };
9030
9031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9032 if (obj0) {
9033 {
9034 arg1 = (bool)(SWIG_As_bool(obj0));
9035 if (SWIG_arg_fail(1)) SWIG_fail;
9036 }
9037 }
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxLog::SetVerbose(arg1);
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxLogLevel arg1 ;
9055 PyObject * obj0 = 0 ;
9056 char *kwnames[] = {
9057 (char *) "logLevel", NULL
9058 };
9059
9060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9061 {
9062 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9063 if (SWIG_arg_fail(1)) SWIG_fail;
9064 }
9065 {
9066 PyThreadState* __tstate = wxPyBeginAllowThreads();
9067 wxLog::SetLogLevel(arg1);
9068
9069 wxPyEndAllowThreads(__tstate);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 Py_INCREF(Py_None); resultobj = Py_None;
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9080 PyObject *resultobj;
9081 char *kwnames[] = {
9082 NULL
9083 };
9084
9085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 wxLog::DontCreateOnDemand();
9089
9090 wxPyEndAllowThreads(__tstate);
9091 if (PyErr_Occurred()) SWIG_fail;
9092 }
9093 Py_INCREF(Py_None); resultobj = Py_None;
9094 return resultobj;
9095 fail:
9096 return NULL;
9097 }
9098
9099
9100 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9101 PyObject *resultobj;
9102 wxTraceMask arg1 ;
9103 PyObject * obj0 = 0 ;
9104 char *kwnames[] = {
9105 (char *) "ulMask", NULL
9106 };
9107
9108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9109 {
9110 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9111 if (SWIG_arg_fail(1)) SWIG_fail;
9112 }
9113 {
9114 PyThreadState* __tstate = wxPyBeginAllowThreads();
9115 wxLog::SetTraceMask(arg1);
9116
9117 wxPyEndAllowThreads(__tstate);
9118 if (PyErr_Occurred()) SWIG_fail;
9119 }
9120 Py_INCREF(Py_None); resultobj = Py_None;
9121 return resultobj;
9122 fail:
9123 return NULL;
9124 }
9125
9126
9127 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9128 PyObject *resultobj;
9129 wxString *arg1 = 0 ;
9130 bool temp1 = false ;
9131 PyObject * obj0 = 0 ;
9132 char *kwnames[] = {
9133 (char *) "str", NULL
9134 };
9135
9136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9137 {
9138 arg1 = wxString_in_helper(obj0);
9139 if (arg1 == NULL) SWIG_fail;
9140 temp1 = true;
9141 }
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 wxLog::AddTraceMask((wxString const &)*arg1);
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 Py_INCREF(Py_None); resultobj = Py_None;
9150 {
9151 if (temp1)
9152 delete arg1;
9153 }
9154 return resultobj;
9155 fail:
9156 {
9157 if (temp1)
9158 delete arg1;
9159 }
9160 return NULL;
9161 }
9162
9163
9164 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9165 PyObject *resultobj;
9166 wxString *arg1 = 0 ;
9167 bool temp1 = false ;
9168 PyObject * obj0 = 0 ;
9169 char *kwnames[] = {
9170 (char *) "str", NULL
9171 };
9172
9173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9174 {
9175 arg1 = wxString_in_helper(obj0);
9176 if (arg1 == NULL) SWIG_fail;
9177 temp1 = true;
9178 }
9179 {
9180 PyThreadState* __tstate = wxPyBeginAllowThreads();
9181 wxLog::RemoveTraceMask((wxString const &)*arg1);
9182
9183 wxPyEndAllowThreads(__tstate);
9184 if (PyErr_Occurred()) SWIG_fail;
9185 }
9186 Py_INCREF(Py_None); resultobj = Py_None;
9187 {
9188 if (temp1)
9189 delete arg1;
9190 }
9191 return resultobj;
9192 fail:
9193 {
9194 if (temp1)
9195 delete arg1;
9196 }
9197 return NULL;
9198 }
9199
9200
9201 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9202 PyObject *resultobj;
9203 char *kwnames[] = {
9204 NULL
9205 };
9206
9207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9208 {
9209 PyThreadState* __tstate = wxPyBeginAllowThreads();
9210 wxLog::ClearTraceMasks();
9211
9212 wxPyEndAllowThreads(__tstate);
9213 if (PyErr_Occurred()) SWIG_fail;
9214 }
9215 Py_INCREF(Py_None); resultobj = Py_None;
9216 return resultobj;
9217 fail:
9218 return NULL;
9219 }
9220
9221
9222 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9223 PyObject *resultobj;
9224 wxArrayString *result;
9225 char *kwnames[] = {
9226 NULL
9227 };
9228
9229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 {
9233 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9234 result = (wxArrayString *) &_result_ref;
9235 }
9236
9237 wxPyEndAllowThreads(__tstate);
9238 if (PyErr_Occurred()) SWIG_fail;
9239 }
9240 {
9241 resultobj = wxArrayString2PyList_helper(*result);
9242 }
9243 return resultobj;
9244 fail:
9245 return NULL;
9246 }
9247
9248
9249 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9250 PyObject *resultobj;
9251 wxChar *arg1 = (wxChar *) 0 ;
9252 PyObject * obj0 = 0 ;
9253 char *kwnames[] = {
9254 (char *) "ts", NULL
9255 };
9256
9257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9259 if (SWIG_arg_fail(1)) SWIG_fail;
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 wxLog::SetTimestamp((wxChar const *)arg1);
9263
9264 wxPyEndAllowThreads(__tstate);
9265 if (PyErr_Occurred()) SWIG_fail;
9266 }
9267 Py_INCREF(Py_None); resultobj = Py_None;
9268 return resultobj;
9269 fail:
9270 return NULL;
9271 }
9272
9273
9274 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 bool result;
9277 char *kwnames[] = {
9278 NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (bool)wxLog::GetVerbose();
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 {
9290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9291 }
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxTraceMask result;
9301 char *kwnames[] = {
9302 NULL
9303 };
9304
9305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9306 {
9307 PyThreadState* __tstate = wxPyBeginAllowThreads();
9308 result = (wxTraceMask)wxLog::GetTraceMask();
9309
9310 wxPyEndAllowThreads(__tstate);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 {
9314 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9315 }
9316 return resultobj;
9317 fail:
9318 return NULL;
9319 }
9320
9321
9322 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9323 PyObject *resultobj;
9324 wxChar *arg1 = (wxChar *) 0 ;
9325 bool result;
9326 PyObject * obj0 = 0 ;
9327 char *kwnames[] = {
9328 (char *) "mask", NULL
9329 };
9330
9331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9333 if (SWIG_arg_fail(1)) SWIG_fail;
9334 {
9335 PyThreadState* __tstate = wxPyBeginAllowThreads();
9336 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9337
9338 wxPyEndAllowThreads(__tstate);
9339 if (PyErr_Occurred()) SWIG_fail;
9340 }
9341 {
9342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9343 }
9344 return resultobj;
9345 fail:
9346 return NULL;
9347 }
9348
9349
9350 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9351 PyObject *resultobj;
9352 wxLogLevel result;
9353 char *kwnames[] = {
9354 NULL
9355 };
9356
9357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9358 {
9359 PyThreadState* __tstate = wxPyBeginAllowThreads();
9360 result = (wxLogLevel)wxLog::GetLogLevel();
9361
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 {
9366 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9367 }
9368 return resultobj;
9369 fail:
9370 return NULL;
9371 }
9372
9373
9374 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9375 PyObject *resultobj;
9376 wxChar *result;
9377 char *kwnames[] = {
9378 NULL
9379 };
9380
9381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (wxChar *)wxLog::GetTimestamp();
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9390 return resultobj;
9391 fail:
9392 return NULL;
9393 }
9394
9395
9396 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj;
9398 wxString result;
9399 char *kwnames[] = {
9400 NULL
9401 };
9402
9403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = Log_TimeStamp();
9407
9408 wxPyEndAllowThreads(__tstate);
9409 if (PyErr_Occurred()) SWIG_fail;
9410 }
9411 {
9412 #if wxUSE_UNICODE
9413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9414 #else
9415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9416 #endif
9417 }
9418 return resultobj;
9419 fail:
9420 return NULL;
9421 }
9422
9423
9424 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9425 PyObject *resultobj;
9426 wxLog *arg1 = (wxLog *) 0 ;
9427 PyObject * obj0 = 0 ;
9428 char *kwnames[] = {
9429 (char *) "self", NULL
9430 };
9431
9432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9434 if (SWIG_arg_fail(1)) SWIG_fail;
9435 {
9436 PyThreadState* __tstate = wxPyBeginAllowThreads();
9437 wxLog_Destroy(arg1);
9438
9439 wxPyEndAllowThreads(__tstate);
9440 if (PyErr_Occurred()) SWIG_fail;
9441 }
9442 Py_INCREF(Py_None); resultobj = Py_None;
9443 return resultobj;
9444 fail:
9445 return NULL;
9446 }
9447
9448
9449 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9450 PyObject *obj;
9451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9452 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9453 Py_INCREF(obj);
9454 return Py_BuildValue((char *)"");
9455 }
9456 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9457 PyObject *resultobj;
9458 wxLogStderr *result;
9459 char *kwnames[] = {
9460 NULL
9461 };
9462
9463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (wxLogStderr *)new wxLogStderr();
9467
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9479 PyObject *obj;
9480 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9481 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9482 Py_INCREF(obj);
9483 return Py_BuildValue((char *)"");
9484 }
9485 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9486 PyObject *resultobj;
9487 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9488 wxLogTextCtrl *result;
9489 PyObject * obj0 = 0 ;
9490 char *kwnames[] = {
9491 (char *) "pTextCtrl", NULL
9492 };
9493
9494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9496 if (SWIG_arg_fail(1)) SWIG_fail;
9497 {
9498 PyThreadState* __tstate = wxPyBeginAllowThreads();
9499 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9500
9501 wxPyEndAllowThreads(__tstate);
9502 if (PyErr_Occurred()) SWIG_fail;
9503 }
9504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9505 return resultobj;
9506 fail:
9507 return NULL;
9508 }
9509
9510
9511 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9512 PyObject *obj;
9513 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9514 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9515 Py_INCREF(obj);
9516 return Py_BuildValue((char *)"");
9517 }
9518 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9519 PyObject *resultobj;
9520 wxLogGui *result;
9521 char *kwnames[] = {
9522 NULL
9523 };
9524
9525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 result = (wxLogGui *)new wxLogGui();
9529
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9534 return resultobj;
9535 fail:
9536 return NULL;
9537 }
9538
9539
9540 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9541 PyObject *obj;
9542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9543 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9544 Py_INCREF(obj);
9545 return Py_BuildValue((char *)"");
9546 }
9547 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9548 PyObject *resultobj;
9549 wxFrame *arg1 = (wxFrame *) 0 ;
9550 wxString *arg2 = 0 ;
9551 bool arg3 = (bool) true ;
9552 bool arg4 = (bool) true ;
9553 wxLogWindow *result;
9554 bool temp2 = false ;
9555 PyObject * obj0 = 0 ;
9556 PyObject * obj1 = 0 ;
9557 PyObject * obj2 = 0 ;
9558 PyObject * obj3 = 0 ;
9559 char *kwnames[] = {
9560 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9561 };
9562
9563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9565 if (SWIG_arg_fail(1)) SWIG_fail;
9566 {
9567 arg2 = wxString_in_helper(obj1);
9568 if (arg2 == NULL) SWIG_fail;
9569 temp2 = true;
9570 }
9571 if (obj2) {
9572 {
9573 arg3 = (bool)(SWIG_As_bool(obj2));
9574 if (SWIG_arg_fail(3)) SWIG_fail;
9575 }
9576 }
9577 if (obj3) {
9578 {
9579 arg4 = (bool)(SWIG_As_bool(obj3));
9580 if (SWIG_arg_fail(4)) SWIG_fail;
9581 }
9582 }
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9586
9587 wxPyEndAllowThreads(__tstate);
9588 if (PyErr_Occurred()) SWIG_fail;
9589 }
9590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9591 {
9592 if (temp2)
9593 delete arg2;
9594 }
9595 return resultobj;
9596 fail:
9597 {
9598 if (temp2)
9599 delete arg2;
9600 }
9601 return NULL;
9602 }
9603
9604
9605 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9606 PyObject *resultobj;
9607 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9608 bool arg2 = (bool) true ;
9609 PyObject * obj0 = 0 ;
9610 PyObject * obj1 = 0 ;
9611 char *kwnames[] = {
9612 (char *) "self",(char *) "bShow", NULL
9613 };
9614
9615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9617 if (SWIG_arg_fail(1)) SWIG_fail;
9618 if (obj1) {
9619 {
9620 arg2 = (bool)(SWIG_As_bool(obj1));
9621 if (SWIG_arg_fail(2)) SWIG_fail;
9622 }
9623 }
9624 {
9625 PyThreadState* __tstate = wxPyBeginAllowThreads();
9626 (arg1)->Show(arg2);
9627
9628 wxPyEndAllowThreads(__tstate);
9629 if (PyErr_Occurred()) SWIG_fail;
9630 }
9631 Py_INCREF(Py_None); resultobj = Py_None;
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9639 PyObject *resultobj;
9640 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9641 wxFrame *result;
9642 PyObject * obj0 = 0 ;
9643 char *kwnames[] = {
9644 (char *) "self", NULL
9645 };
9646
9647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(1)) SWIG_fail;
9650 {
9651 PyThreadState* __tstate = wxPyBeginAllowThreads();
9652 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9653
9654 wxPyEndAllowThreads(__tstate);
9655 if (PyErr_Occurred()) SWIG_fail;
9656 }
9657 {
9658 resultobj = wxPyMake_wxObject(result, 0);
9659 }
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9667 PyObject *resultobj;
9668 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9669 wxLog *result;
9670 PyObject * obj0 = 0 ;
9671 char *kwnames[] = {
9672 (char *) "self", NULL
9673 };
9674
9675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9677 if (SWIG_arg_fail(1)) SWIG_fail;
9678 {
9679 PyThreadState* __tstate = wxPyBeginAllowThreads();
9680 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9681
9682 wxPyEndAllowThreads(__tstate);
9683 if (PyErr_Occurred()) SWIG_fail;
9684 }
9685 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9686 return resultobj;
9687 fail:
9688 return NULL;
9689 }
9690
9691
9692 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9693 PyObject *resultobj;
9694 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9695 bool result;
9696 PyObject * obj0 = 0 ;
9697 char *kwnames[] = {
9698 (char *) "self", NULL
9699 };
9700
9701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(1)) SWIG_fail;
9704 {
9705 PyThreadState* __tstate = wxPyBeginAllowThreads();
9706 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9707
9708 wxPyEndAllowThreads(__tstate);
9709 if (PyErr_Occurred()) SWIG_fail;
9710 }
9711 {
9712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9713 }
9714 return resultobj;
9715 fail:
9716 return NULL;
9717 }
9718
9719
9720 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9721 PyObject *resultobj;
9722 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9723 bool arg2 ;
9724 PyObject * obj0 = 0 ;
9725 PyObject * obj1 = 0 ;
9726 char *kwnames[] = {
9727 (char *) "self",(char *) "bDoPass", NULL
9728 };
9729
9730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9732 if (SWIG_arg_fail(1)) SWIG_fail;
9733 {
9734 arg2 = (bool)(SWIG_As_bool(obj1));
9735 if (SWIG_arg_fail(2)) SWIG_fail;
9736 }
9737 {
9738 PyThreadState* __tstate = wxPyBeginAllowThreads();
9739 (arg1)->PassMessages(arg2);
9740
9741 wxPyEndAllowThreads(__tstate);
9742 if (PyErr_Occurred()) SWIG_fail;
9743 }
9744 Py_INCREF(Py_None); resultobj = Py_None;
9745 return resultobj;
9746 fail:
9747 return NULL;
9748 }
9749
9750
9751 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9752 PyObject *obj;
9753 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9754 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9755 Py_INCREF(obj);
9756 return Py_BuildValue((char *)"");
9757 }
9758 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9759 PyObject *resultobj;
9760 wxLog *arg1 = (wxLog *) 0 ;
9761 wxLogChain *result;
9762 PyObject * obj0 = 0 ;
9763 char *kwnames[] = {
9764 (char *) "logger", NULL
9765 };
9766
9767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9769 if (SWIG_arg_fail(1)) SWIG_fail;
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (wxLogChain *)new wxLogChain(arg1);
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj;
9786 wxLogChain *arg1 = (wxLogChain *) 0 ;
9787 wxLog *arg2 = (wxLog *) 0 ;
9788 PyObject * obj0 = 0 ;
9789 PyObject * obj1 = 0 ;
9790 char *kwnames[] = {
9791 (char *) "self",(char *) "logger", NULL
9792 };
9793
9794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9796 if (SWIG_arg_fail(1)) SWIG_fail;
9797 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9798 if (SWIG_arg_fail(2)) SWIG_fail;
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 (arg1)->SetLog(arg2);
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 Py_INCREF(Py_None); resultobj = Py_None;
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj;
9815 wxLogChain *arg1 = (wxLogChain *) 0 ;
9816 bool arg2 ;
9817 PyObject * obj0 = 0 ;
9818 PyObject * obj1 = 0 ;
9819 char *kwnames[] = {
9820 (char *) "self",(char *) "bDoPass", NULL
9821 };
9822
9823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9825 if (SWIG_arg_fail(1)) SWIG_fail;
9826 {
9827 arg2 = (bool)(SWIG_As_bool(obj1));
9828 if (SWIG_arg_fail(2)) SWIG_fail;
9829 }
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 (arg1)->PassMessages(arg2);
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 Py_INCREF(Py_None); resultobj = Py_None;
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9845 PyObject *resultobj;
9846 wxLogChain *arg1 = (wxLogChain *) 0 ;
9847 bool result;
9848 PyObject * obj0 = 0 ;
9849 char *kwnames[] = {
9850 (char *) "self", NULL
9851 };
9852
9853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9855 if (SWIG_arg_fail(1)) SWIG_fail;
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 result = (bool)(arg1)->IsPassingMessages();
9859
9860 wxPyEndAllowThreads(__tstate);
9861 if (PyErr_Occurred()) SWIG_fail;
9862 }
9863 {
9864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9865 }
9866 return resultobj;
9867 fail:
9868 return NULL;
9869 }
9870
9871
9872 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9873 PyObject *resultobj;
9874 wxLogChain *arg1 = (wxLogChain *) 0 ;
9875 wxLog *result;
9876 PyObject * obj0 = 0 ;
9877 char *kwnames[] = {
9878 (char *) "self", NULL
9879 };
9880
9881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9883 if (SWIG_arg_fail(1)) SWIG_fail;
9884 {
9885 PyThreadState* __tstate = wxPyBeginAllowThreads();
9886 result = (wxLog *)(arg1)->GetOldLog();
9887
9888 wxPyEndAllowThreads(__tstate);
9889 if (PyErr_Occurred()) SWIG_fail;
9890 }
9891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9892 return resultobj;
9893 fail:
9894 return NULL;
9895 }
9896
9897
9898 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9899 PyObject *obj;
9900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9901 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9902 Py_INCREF(obj);
9903 return Py_BuildValue((char *)"");
9904 }
9905 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9906 PyObject *resultobj;
9907 unsigned long result;
9908 char *kwnames[] = {
9909 NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9913 {
9914 PyThreadState* __tstate = wxPyBeginAllowThreads();
9915 result = (unsigned long)wxSysErrorCode();
9916
9917 wxPyEndAllowThreads(__tstate);
9918 if (PyErr_Occurred()) SWIG_fail;
9919 }
9920 {
9921 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9922 }
9923 return resultobj;
9924 fail:
9925 return NULL;
9926 }
9927
9928
9929 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9930 PyObject *resultobj;
9931 unsigned long arg1 = (unsigned long) 0 ;
9932 wxString result;
9933 PyObject * obj0 = 0 ;
9934 char *kwnames[] = {
9935 (char *) "nErrCode", NULL
9936 };
9937
9938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9939 if (obj0) {
9940 {
9941 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9942 if (SWIG_arg_fail(1)) SWIG_fail;
9943 }
9944 }
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 result = wxSysErrorMsg(arg1);
9948
9949 wxPyEndAllowThreads(__tstate);
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 {
9953 #if wxUSE_UNICODE
9954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9955 #else
9956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9957 #endif
9958 }
9959 return resultobj;
9960 fail:
9961 return NULL;
9962 }
9963
9964
9965 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9966 PyObject *resultobj;
9967 wxString *arg1 = 0 ;
9968 bool temp1 = false ;
9969 PyObject * obj0 = 0 ;
9970 char *kwnames[] = {
9971 (char *) "msg", NULL
9972 };
9973
9974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9975 {
9976 arg1 = wxString_in_helper(obj0);
9977 if (arg1 == NULL) SWIG_fail;
9978 temp1 = true;
9979 }
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 wxPyLogFatalError((wxString const &)*arg1);
9983
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 Py_INCREF(Py_None); resultobj = Py_None;
9988 {
9989 if (temp1)
9990 delete arg1;
9991 }
9992 return resultobj;
9993 fail:
9994 {
9995 if (temp1)
9996 delete arg1;
9997 }
9998 return NULL;
9999 }
10000
10001
10002 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10003 PyObject *resultobj;
10004 wxString *arg1 = 0 ;
10005 bool temp1 = false ;
10006 PyObject * obj0 = 0 ;
10007 char *kwnames[] = {
10008 (char *) "msg", NULL
10009 };
10010
10011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10012 {
10013 arg1 = wxString_in_helper(obj0);
10014 if (arg1 == NULL) SWIG_fail;
10015 temp1 = true;
10016 }
10017 {
10018 PyThreadState* __tstate = wxPyBeginAllowThreads();
10019 wxPyLogError((wxString const &)*arg1);
10020
10021 wxPyEndAllowThreads(__tstate);
10022 if (PyErr_Occurred()) SWIG_fail;
10023 }
10024 Py_INCREF(Py_None); resultobj = Py_None;
10025 {
10026 if (temp1)
10027 delete arg1;
10028 }
10029 return resultobj;
10030 fail:
10031 {
10032 if (temp1)
10033 delete arg1;
10034 }
10035 return NULL;
10036 }
10037
10038
10039 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj;
10041 wxString *arg1 = 0 ;
10042 bool temp1 = false ;
10043 PyObject * obj0 = 0 ;
10044 char *kwnames[] = {
10045 (char *) "msg", NULL
10046 };
10047
10048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10049 {
10050 arg1 = wxString_in_helper(obj0);
10051 if (arg1 == NULL) SWIG_fail;
10052 temp1 = true;
10053 }
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 wxPyLogWarning((wxString const &)*arg1);
10057
10058 wxPyEndAllowThreads(__tstate);
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 Py_INCREF(Py_None); resultobj = Py_None;
10062 {
10063 if (temp1)
10064 delete arg1;
10065 }
10066 return resultobj;
10067 fail:
10068 {
10069 if (temp1)
10070 delete arg1;
10071 }
10072 return NULL;
10073 }
10074
10075
10076 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10077 PyObject *resultobj;
10078 wxString *arg1 = 0 ;
10079 bool temp1 = false ;
10080 PyObject * obj0 = 0 ;
10081 char *kwnames[] = {
10082 (char *) "msg", NULL
10083 };
10084
10085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10086 {
10087 arg1 = wxString_in_helper(obj0);
10088 if (arg1 == NULL) SWIG_fail;
10089 temp1 = true;
10090 }
10091 {
10092 PyThreadState* __tstate = wxPyBeginAllowThreads();
10093 wxPyLogMessage((wxString const &)*arg1);
10094
10095 wxPyEndAllowThreads(__tstate);
10096 if (PyErr_Occurred()) SWIG_fail;
10097 }
10098 Py_INCREF(Py_None); resultobj = Py_None;
10099 {
10100 if (temp1)
10101 delete arg1;
10102 }
10103 return resultobj;
10104 fail:
10105 {
10106 if (temp1)
10107 delete arg1;
10108 }
10109 return NULL;
10110 }
10111
10112
10113 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10114 PyObject *resultobj;
10115 wxString *arg1 = 0 ;
10116 bool temp1 = false ;
10117 PyObject * obj0 = 0 ;
10118 char *kwnames[] = {
10119 (char *) "msg", NULL
10120 };
10121
10122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10123 {
10124 arg1 = wxString_in_helper(obj0);
10125 if (arg1 == NULL) SWIG_fail;
10126 temp1 = true;
10127 }
10128 {
10129 PyThreadState* __tstate = wxPyBeginAllowThreads();
10130 wxPyLogInfo((wxString const &)*arg1);
10131
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 Py_INCREF(Py_None); resultobj = Py_None;
10136 {
10137 if (temp1)
10138 delete arg1;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp1)
10144 delete arg1;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj;
10152 wxString *arg1 = 0 ;
10153 bool temp1 = false ;
10154 PyObject * obj0 = 0 ;
10155 char *kwnames[] = {
10156 (char *) "msg", NULL
10157 };
10158
10159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10160 {
10161 arg1 = wxString_in_helper(obj0);
10162 if (arg1 == NULL) SWIG_fail;
10163 temp1 = true;
10164 }
10165 {
10166 PyThreadState* __tstate = wxPyBeginAllowThreads();
10167 wxPyLogDebug((wxString const &)*arg1);
10168
10169 wxPyEndAllowThreads(__tstate);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 Py_INCREF(Py_None); resultobj = Py_None;
10173 {
10174 if (temp1)
10175 delete arg1;
10176 }
10177 return resultobj;
10178 fail:
10179 {
10180 if (temp1)
10181 delete arg1;
10182 }
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 wxString *arg1 = 0 ;
10190 bool temp1 = false ;
10191 PyObject * obj0 = 0 ;
10192 char *kwnames[] = {
10193 (char *) "msg", NULL
10194 };
10195
10196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10197 {
10198 arg1 = wxString_in_helper(obj0);
10199 if (arg1 == NULL) SWIG_fail;
10200 temp1 = true;
10201 }
10202 {
10203 PyThreadState* __tstate = wxPyBeginAllowThreads();
10204 wxPyLogVerbose((wxString const &)*arg1);
10205
10206 wxPyEndAllowThreads(__tstate);
10207 if (PyErr_Occurred()) SWIG_fail;
10208 }
10209 Py_INCREF(Py_None); resultobj = Py_None;
10210 {
10211 if (temp1)
10212 delete arg1;
10213 }
10214 return resultobj;
10215 fail:
10216 {
10217 if (temp1)
10218 delete arg1;
10219 }
10220 return NULL;
10221 }
10222
10223
10224 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10225 PyObject *resultobj;
10226 wxString *arg1 = 0 ;
10227 bool temp1 = false ;
10228 PyObject * obj0 = 0 ;
10229 char *kwnames[] = {
10230 (char *) "msg", NULL
10231 };
10232
10233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10234 {
10235 arg1 = wxString_in_helper(obj0);
10236 if (arg1 == NULL) SWIG_fail;
10237 temp1 = true;
10238 }
10239 {
10240 PyThreadState* __tstate = wxPyBeginAllowThreads();
10241 wxPyLogStatus((wxString const &)*arg1);
10242
10243 wxPyEndAllowThreads(__tstate);
10244 if (PyErr_Occurred()) SWIG_fail;
10245 }
10246 Py_INCREF(Py_None); resultobj = Py_None;
10247 {
10248 if (temp1)
10249 delete arg1;
10250 }
10251 return resultobj;
10252 fail:
10253 {
10254 if (temp1)
10255 delete arg1;
10256 }
10257 return NULL;
10258 }
10259
10260
10261 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10262 PyObject *resultobj;
10263 wxFrame *arg1 = (wxFrame *) 0 ;
10264 wxString *arg2 = 0 ;
10265 bool temp2 = false ;
10266 PyObject * obj0 = 0 ;
10267 PyObject * obj1 = 0 ;
10268 char *kwnames[] = {
10269 (char *) "pFrame",(char *) "msg", NULL
10270 };
10271
10272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10274 if (SWIG_arg_fail(1)) SWIG_fail;
10275 {
10276 arg2 = wxString_in_helper(obj1);
10277 if (arg2 == NULL) SWIG_fail;
10278 temp2 = true;
10279 }
10280 {
10281 PyThreadState* __tstate = wxPyBeginAllowThreads();
10282 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10283
10284 wxPyEndAllowThreads(__tstate);
10285 if (PyErr_Occurred()) SWIG_fail;
10286 }
10287 Py_INCREF(Py_None); resultobj = Py_None;
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10303 PyObject *resultobj;
10304 wxString *arg1 = 0 ;
10305 bool temp1 = false ;
10306 PyObject * obj0 = 0 ;
10307 char *kwnames[] = {
10308 (char *) "msg", NULL
10309 };
10310
10311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10312 {
10313 arg1 = wxString_in_helper(obj0);
10314 if (arg1 == NULL) SWIG_fail;
10315 temp1 = true;
10316 }
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 wxPyLogSysError((wxString const &)*arg1);
10320
10321 wxPyEndAllowThreads(__tstate);
10322 if (PyErr_Occurred()) SWIG_fail;
10323 }
10324 Py_INCREF(Py_None); resultobj = Py_None;
10325 {
10326 if (temp1)
10327 delete arg1;
10328 }
10329 return resultobj;
10330 fail:
10331 {
10332 if (temp1)
10333 delete arg1;
10334 }
10335 return NULL;
10336 }
10337
10338
10339 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10340 PyObject *resultobj;
10341 unsigned long arg1 ;
10342 wxString *arg2 = 0 ;
10343 bool temp2 = false ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char *kwnames[] = {
10347 (char *) "level",(char *) "msg", NULL
10348 };
10349
10350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10351 {
10352 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10353 if (SWIG_arg_fail(1)) SWIG_fail;
10354 }
10355 {
10356 arg2 = wxString_in_helper(obj1);
10357 if (arg2 == NULL) SWIG_fail;
10358 temp2 = true;
10359 }
10360 {
10361 PyThreadState* __tstate = wxPyBeginAllowThreads();
10362 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10363
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 Py_INCREF(Py_None); resultobj = Py_None;
10368 {
10369 if (temp2)
10370 delete arg2;
10371 }
10372 return resultobj;
10373 fail:
10374 {
10375 if (temp2)
10376 delete arg2;
10377 }
10378 return NULL;
10379 }
10380
10381
10382 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10383 PyObject *resultobj;
10384 unsigned long arg1 ;
10385 wxString *arg2 = 0 ;
10386 bool temp2 = false ;
10387 PyObject * obj0 = 0 ;
10388 PyObject * obj1 = 0 ;
10389
10390 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10391 {
10392 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10393 if (SWIG_arg_fail(1)) SWIG_fail;
10394 }
10395 {
10396 arg2 = wxString_in_helper(obj1);
10397 if (arg2 == NULL) SWIG_fail;
10398 temp2 = true;
10399 }
10400 {
10401 PyThreadState* __tstate = wxPyBeginAllowThreads();
10402 wxPyLogTrace(arg1,(wxString const &)*arg2);
10403
10404 wxPyEndAllowThreads(__tstate);
10405 if (PyErr_Occurred()) SWIG_fail;
10406 }
10407 Py_INCREF(Py_None); resultobj = Py_None;
10408 {
10409 if (temp2)
10410 delete arg2;
10411 }
10412 return resultobj;
10413 fail:
10414 {
10415 if (temp2)
10416 delete arg2;
10417 }
10418 return NULL;
10419 }
10420
10421
10422 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10423 PyObject *resultobj;
10424 wxString *arg1 = 0 ;
10425 wxString *arg2 = 0 ;
10426 bool temp1 = false ;
10427 bool temp2 = false ;
10428 PyObject * obj0 = 0 ;
10429 PyObject * obj1 = 0 ;
10430
10431 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10432 {
10433 arg1 = wxString_in_helper(obj0);
10434 if (arg1 == NULL) SWIG_fail;
10435 temp1 = true;
10436 }
10437 {
10438 arg2 = wxString_in_helper(obj1);
10439 if (arg2 == NULL) SWIG_fail;
10440 temp2 = true;
10441 }
10442 {
10443 PyThreadState* __tstate = wxPyBeginAllowThreads();
10444 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10445
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 Py_INCREF(Py_None); resultobj = Py_None;
10450 {
10451 if (temp1)
10452 delete arg1;
10453 }
10454 {
10455 if (temp2)
10456 delete arg2;
10457 }
10458 return resultobj;
10459 fail:
10460 {
10461 if (temp1)
10462 delete arg1;
10463 }
10464 {
10465 if (temp2)
10466 delete arg2;
10467 }
10468 return NULL;
10469 }
10470
10471
10472 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10473 int argc;
10474 PyObject *argv[3];
10475 int ii;
10476
10477 argc = PyObject_Length(args);
10478 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10479 argv[ii] = PyTuple_GetItem(args,ii);
10480 }
10481 if (argc == 2) {
10482 int _v;
10483 {
10484 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10485 }
10486 if (_v) {
10487 {
10488 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10489 }
10490 if (_v) {
10491 return _wrap_LogTrace__SWIG_1(self,args);
10492 }
10493 }
10494 }
10495 if (argc == 2) {
10496 int _v;
10497 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10498 if (_v) {
10499 {
10500 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10501 }
10502 if (_v) {
10503 return _wrap_LogTrace__SWIG_0(self,args);
10504 }
10505 }
10506 }
10507
10508 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10509 return NULL;
10510 }
10511
10512
10513 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10514 PyObject *resultobj;
10515 wxString *arg1 = 0 ;
10516 wxString *arg2 = 0 ;
10517 bool temp1 = false ;
10518 bool temp2 = false ;
10519 PyObject * obj0 = 0 ;
10520 PyObject * obj1 = 0 ;
10521 char *kwnames[] = {
10522 (char *) "title",(char *) "text", NULL
10523 };
10524
10525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10526 {
10527 arg1 = wxString_in_helper(obj0);
10528 if (arg1 == NULL) SWIG_fail;
10529 temp1 = true;
10530 }
10531 {
10532 arg2 = wxString_in_helper(obj1);
10533 if (arg2 == NULL) SWIG_fail;
10534 temp2 = true;
10535 }
10536 {
10537 PyThreadState* __tstate = wxPyBeginAllowThreads();
10538 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10539
10540 wxPyEndAllowThreads(__tstate);
10541 if (PyErr_Occurred()) SWIG_fail;
10542 }
10543 Py_INCREF(Py_None); resultobj = Py_None;
10544 {
10545 if (temp1)
10546 delete arg1;
10547 }
10548 {
10549 if (temp2)
10550 delete arg2;
10551 }
10552 return resultobj;
10553 fail:
10554 {
10555 if (temp1)
10556 delete arg1;
10557 }
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return NULL;
10563 }
10564
10565
10566 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj;
10568 wxLogNull *result;
10569 char *kwnames[] = {
10570 NULL
10571 };
10572
10573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (wxLogNull *)new wxLogNull();
10577
10578 wxPyEndAllowThreads(__tstate);
10579 if (PyErr_Occurred()) SWIG_fail;
10580 }
10581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10582 return resultobj;
10583 fail:
10584 return NULL;
10585 }
10586
10587
10588 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10589 PyObject *resultobj;
10590 wxLogNull *arg1 = (wxLogNull *) 0 ;
10591 PyObject * obj0 = 0 ;
10592 char *kwnames[] = {
10593 (char *) "self", NULL
10594 };
10595
10596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10598 if (SWIG_arg_fail(1)) SWIG_fail;
10599 {
10600 PyThreadState* __tstate = wxPyBeginAllowThreads();
10601 delete arg1;
10602
10603 wxPyEndAllowThreads(__tstate);
10604 if (PyErr_Occurred()) SWIG_fail;
10605 }
10606 Py_INCREF(Py_None); resultobj = Py_None;
10607 return resultobj;
10608 fail:
10609 return NULL;
10610 }
10611
10612
10613 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10614 PyObject *obj;
10615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10616 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10617 Py_INCREF(obj);
10618 return Py_BuildValue((char *)"");
10619 }
10620 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10621 PyObject *resultobj;
10622 wxPyLog *result;
10623 char *kwnames[] = {
10624 NULL
10625 };
10626
10627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10628 {
10629 PyThreadState* __tstate = wxPyBeginAllowThreads();
10630 result = (wxPyLog *)new wxPyLog();
10631
10632 wxPyEndAllowThreads(__tstate);
10633 if (PyErr_Occurred()) SWIG_fail;
10634 }
10635 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10636 return resultobj;
10637 fail:
10638 return NULL;
10639 }
10640
10641
10642 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10643 PyObject *resultobj;
10644 wxPyLog *arg1 = (wxPyLog *) 0 ;
10645 PyObject *arg2 = (PyObject *) 0 ;
10646 PyObject *arg3 = (PyObject *) 0 ;
10647 PyObject * obj0 = 0 ;
10648 PyObject * obj1 = 0 ;
10649 PyObject * obj2 = 0 ;
10650 char *kwnames[] = {
10651 (char *) "self",(char *) "self",(char *) "_class", NULL
10652 };
10653
10654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10656 if (SWIG_arg_fail(1)) SWIG_fail;
10657 arg2 = obj1;
10658 arg3 = obj2;
10659 {
10660 PyThreadState* __tstate = wxPyBeginAllowThreads();
10661 (arg1)->_setCallbackInfo(arg2,arg3);
10662
10663 wxPyEndAllowThreads(__tstate);
10664 if (PyErr_Occurred()) SWIG_fail;
10665 }
10666 Py_INCREF(Py_None); resultobj = Py_None;
10667 return resultobj;
10668 fail:
10669 return NULL;
10670 }
10671
10672
10673 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10674 PyObject *obj;
10675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10676 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10677 Py_INCREF(obj);
10678 return Py_BuildValue((char *)"");
10679 }
10680 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10681 PyObject *resultobj;
10682 int arg1 ;
10683 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10684 int arg3 = (int) wxKILL_NOCHILDREN ;
10685 wxKillError result;
10686 PyObject * obj0 = 0 ;
10687 PyObject * obj1 = 0 ;
10688 PyObject * obj2 = 0 ;
10689 char *kwnames[] = {
10690 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10691 };
10692
10693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10694 {
10695 arg1 = (int)(SWIG_As_int(obj0));
10696 if (SWIG_arg_fail(1)) SWIG_fail;
10697 }
10698 if (obj1) {
10699 {
10700 arg2 = (wxSignal)(SWIG_As_int(obj1));
10701 if (SWIG_arg_fail(2)) SWIG_fail;
10702 }
10703 }
10704 if (obj2) {
10705 {
10706 arg3 = (int)(SWIG_As_int(obj2));
10707 if (SWIG_arg_fail(3)) SWIG_fail;
10708 }
10709 }
10710 {
10711 PyThreadState* __tstate = wxPyBeginAllowThreads();
10712 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10713
10714 wxPyEndAllowThreads(__tstate);
10715 if (PyErr_Occurred()) SWIG_fail;
10716 }
10717 resultobj = SWIG_From_int((result));
10718 return resultobj;
10719 fail:
10720 return NULL;
10721 }
10722
10723
10724 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj;
10726 int arg1 ;
10727 bool result;
10728 PyObject * obj0 = 0 ;
10729 char *kwnames[] = {
10730 (char *) "pid", NULL
10731 };
10732
10733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10734 {
10735 arg1 = (int)(SWIG_As_int(obj0));
10736 if (SWIG_arg_fail(1)) SWIG_fail;
10737 }
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (bool)wxPyProcess::Exists(arg1);
10741
10742 wxPyEndAllowThreads(__tstate);
10743 if (PyErr_Occurred()) SWIG_fail;
10744 }
10745 {
10746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10747 }
10748 return resultobj;
10749 fail:
10750 return NULL;
10751 }
10752
10753
10754 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10755 PyObject *resultobj;
10756 wxString *arg1 = 0 ;
10757 int arg2 = (int) wxEXEC_ASYNC ;
10758 wxPyProcess *result;
10759 bool temp1 = false ;
10760 PyObject * obj0 = 0 ;
10761 PyObject * obj1 = 0 ;
10762 char *kwnames[] = {
10763 (char *) "cmd",(char *) "flags", NULL
10764 };
10765
10766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10767 {
10768 arg1 = wxString_in_helper(obj0);
10769 if (arg1 == NULL) SWIG_fail;
10770 temp1 = true;
10771 }
10772 if (obj1) {
10773 {
10774 arg2 = (int)(SWIG_As_int(obj1));
10775 if (SWIG_arg_fail(2)) SWIG_fail;
10776 }
10777 }
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10781
10782 wxPyEndAllowThreads(__tstate);
10783 if (PyErr_Occurred()) SWIG_fail;
10784 }
10785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10786 {
10787 if (temp1)
10788 delete arg1;
10789 }
10790 return resultobj;
10791 fail:
10792 {
10793 if (temp1)
10794 delete arg1;
10795 }
10796 return NULL;
10797 }
10798
10799
10800 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10801 PyObject *resultobj;
10802 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10803 int arg2 = (int) -1 ;
10804 wxPyProcess *result;
10805 PyObject * obj0 = 0 ;
10806 PyObject * obj1 = 0 ;
10807 char *kwnames[] = {
10808 (char *) "parent",(char *) "id", NULL
10809 };
10810
10811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10812 if (obj0) {
10813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10814 if (SWIG_arg_fail(1)) SWIG_fail;
10815 }
10816 if (obj1) {
10817 {
10818 arg2 = (int)(SWIG_As_int(obj1));
10819 if (SWIG_arg_fail(2)) SWIG_fail;
10820 }
10821 }
10822 {
10823 PyThreadState* __tstate = wxPyBeginAllowThreads();
10824 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10825
10826 wxPyEndAllowThreads(__tstate);
10827 if (PyErr_Occurred()) SWIG_fail;
10828 }
10829 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10830 return resultobj;
10831 fail:
10832 return NULL;
10833 }
10834
10835
10836 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10837 PyObject *resultobj;
10838 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10839 PyObject *arg2 = (PyObject *) 0 ;
10840 PyObject *arg3 = (PyObject *) 0 ;
10841 PyObject * obj0 = 0 ;
10842 PyObject * obj1 = 0 ;
10843 PyObject * obj2 = 0 ;
10844 char *kwnames[] = {
10845 (char *) "self",(char *) "self",(char *) "_class", NULL
10846 };
10847
10848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10850 if (SWIG_arg_fail(1)) SWIG_fail;
10851 arg2 = obj1;
10852 arg3 = obj2;
10853 {
10854 PyThreadState* __tstate = wxPyBeginAllowThreads();
10855 (arg1)->_setCallbackInfo(arg2,arg3);
10856
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 Py_INCREF(Py_None); resultobj = Py_None;
10861 return resultobj;
10862 fail:
10863 return NULL;
10864 }
10865
10866
10867 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10868 PyObject *resultobj;
10869 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10870 int arg2 ;
10871 int arg3 ;
10872 PyObject * obj0 = 0 ;
10873 PyObject * obj1 = 0 ;
10874 PyObject * obj2 = 0 ;
10875 char *kwnames[] = {
10876 (char *) "self",(char *) "pid",(char *) "status", NULL
10877 };
10878
10879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10881 if (SWIG_arg_fail(1)) SWIG_fail;
10882 {
10883 arg2 = (int)(SWIG_As_int(obj1));
10884 if (SWIG_arg_fail(2)) SWIG_fail;
10885 }
10886 {
10887 arg3 = (int)(SWIG_As_int(obj2));
10888 if (SWIG_arg_fail(3)) SWIG_fail;
10889 }
10890 {
10891 PyThreadState* __tstate = wxPyBeginAllowThreads();
10892 (arg1)->base_OnTerminate(arg2,arg3);
10893
10894 wxPyEndAllowThreads(__tstate);
10895 if (PyErr_Occurred()) SWIG_fail;
10896 }
10897 Py_INCREF(Py_None); resultobj = Py_None;
10898 return resultobj;
10899 fail:
10900 return NULL;
10901 }
10902
10903
10904 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10905 PyObject *resultobj;
10906 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10907 PyObject * obj0 = 0 ;
10908 char *kwnames[] = {
10909 (char *) "self", NULL
10910 };
10911
10912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10914 if (SWIG_arg_fail(1)) SWIG_fail;
10915 {
10916 PyThreadState* __tstate = wxPyBeginAllowThreads();
10917 (arg1)->Redirect();
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 Py_INCREF(Py_None); resultobj = Py_None;
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10932 bool result;
10933 PyObject * obj0 = 0 ;
10934 char *kwnames[] = {
10935 (char *) "self", NULL
10936 };
10937
10938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10940 if (SWIG_arg_fail(1)) SWIG_fail;
10941 {
10942 PyThreadState* __tstate = wxPyBeginAllowThreads();
10943 result = (bool)(arg1)->IsRedirected();
10944
10945 wxPyEndAllowThreads(__tstate);
10946 if (PyErr_Occurred()) SWIG_fail;
10947 }
10948 {
10949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10950 }
10951 return resultobj;
10952 fail:
10953 return NULL;
10954 }
10955
10956
10957 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10958 PyObject *resultobj;
10959 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10960 PyObject * obj0 = 0 ;
10961 char *kwnames[] = {
10962 (char *) "self", NULL
10963 };
10964
10965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10967 if (SWIG_arg_fail(1)) SWIG_fail;
10968 {
10969 PyThreadState* __tstate = wxPyBeginAllowThreads();
10970 (arg1)->Detach();
10971
10972 wxPyEndAllowThreads(__tstate);
10973 if (PyErr_Occurred()) SWIG_fail;
10974 }
10975 Py_INCREF(Py_None); resultobj = Py_None;
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj;
10984 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10985 wxInputStream *result;
10986 PyObject * obj0 = 0 ;
10987 char *kwnames[] = {
10988 (char *) "self", NULL
10989 };
10990
10991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
10992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10993 if (SWIG_arg_fail(1)) SWIG_fail;
10994 {
10995 PyThreadState* __tstate = wxPyBeginAllowThreads();
10996 result = (wxInputStream *)(arg1)->GetInputStream();
10997
10998 wxPyEndAllowThreads(__tstate);
10999 if (PyErr_Occurred()) SWIG_fail;
11000 }
11001 {
11002 wxPyInputStream * _ptr = NULL;
11003
11004 if (result) {
11005 _ptr = new wxPyInputStream(result);
11006 }
11007 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11018 wxInputStream *result;
11019 PyObject * obj0 = 0 ;
11020 char *kwnames[] = {
11021 (char *) "self", NULL
11022 };
11023
11024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11026 if (SWIG_arg_fail(1)) SWIG_fail;
11027 {
11028 PyThreadState* __tstate = wxPyBeginAllowThreads();
11029 result = (wxInputStream *)(arg1)->GetErrorStream();
11030
11031 wxPyEndAllowThreads(__tstate);
11032 if (PyErr_Occurred()) SWIG_fail;
11033 }
11034 {
11035 wxPyInputStream * _ptr = NULL;
11036
11037 if (result) {
11038 _ptr = new wxPyInputStream(result);
11039 }
11040 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11041 }
11042 return resultobj;
11043 fail:
11044 return NULL;
11045 }
11046
11047
11048 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11049 PyObject *resultobj;
11050 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11051 wxOutputStream *result;
11052 PyObject * obj0 = 0 ;
11053 char *kwnames[] = {
11054 (char *) "self", NULL
11055 };
11056
11057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11059 if (SWIG_arg_fail(1)) SWIG_fail;
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 result = (wxOutputStream *)(arg1)->GetOutputStream();
11063
11064 wxPyEndAllowThreads(__tstate);
11065 if (PyErr_Occurred()) SWIG_fail;
11066 }
11067 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11068 return resultobj;
11069 fail:
11070 return NULL;
11071 }
11072
11073
11074 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11075 PyObject *resultobj;
11076 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11077 PyObject * obj0 = 0 ;
11078 char *kwnames[] = {
11079 (char *) "self", NULL
11080 };
11081
11082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11084 if (SWIG_arg_fail(1)) SWIG_fail;
11085 {
11086 PyThreadState* __tstate = wxPyBeginAllowThreads();
11087 (arg1)->CloseOutput();
11088
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 Py_INCREF(Py_None); resultobj = Py_None;
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj;
11101 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11102 bool result;
11103 PyObject * obj0 = 0 ;
11104 char *kwnames[] = {
11105 (char *) "self", NULL
11106 };
11107
11108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11110 if (SWIG_arg_fail(1)) SWIG_fail;
11111 {
11112 PyThreadState* __tstate = wxPyBeginAllowThreads();
11113 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11114
11115 wxPyEndAllowThreads(__tstate);
11116 if (PyErr_Occurred()) SWIG_fail;
11117 }
11118 {
11119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11120 }
11121 return resultobj;
11122 fail:
11123 return NULL;
11124 }
11125
11126
11127 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11128 PyObject *resultobj;
11129 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11130 bool result;
11131 PyObject * obj0 = 0 ;
11132 char *kwnames[] = {
11133 (char *) "self", NULL
11134 };
11135
11136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11138 if (SWIG_arg_fail(1)) SWIG_fail;
11139 {
11140 PyThreadState* __tstate = wxPyBeginAllowThreads();
11141 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11142
11143 wxPyEndAllowThreads(__tstate);
11144 if (PyErr_Occurred()) SWIG_fail;
11145 }
11146 {
11147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11148 }
11149 return resultobj;
11150 fail:
11151 return NULL;
11152 }
11153
11154
11155 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11156 PyObject *resultobj;
11157 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11158 bool result;
11159 PyObject * obj0 = 0 ;
11160 char *kwnames[] = {
11161 (char *) "self", NULL
11162 };
11163
11164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11166 if (SWIG_arg_fail(1)) SWIG_fail;
11167 {
11168 PyThreadState* __tstate = wxPyBeginAllowThreads();
11169 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11170
11171 wxPyEndAllowThreads(__tstate);
11172 if (PyErr_Occurred()) SWIG_fail;
11173 }
11174 {
11175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11176 }
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11184 PyObject *obj;
11185 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11186 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11187 Py_INCREF(obj);
11188 return Py_BuildValue((char *)"");
11189 }
11190 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11191 PyObject *resultobj;
11192 int arg1 = (int) 0 ;
11193 int arg2 = (int) 0 ;
11194 int arg3 = (int) 0 ;
11195 wxProcessEvent *result;
11196 PyObject * obj0 = 0 ;
11197 PyObject * obj1 = 0 ;
11198 PyObject * obj2 = 0 ;
11199 char *kwnames[] = {
11200 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11201 };
11202
11203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11204 if (obj0) {
11205 {
11206 arg1 = (int)(SWIG_As_int(obj0));
11207 if (SWIG_arg_fail(1)) SWIG_fail;
11208 }
11209 }
11210 if (obj1) {
11211 {
11212 arg2 = (int)(SWIG_As_int(obj1));
11213 if (SWIG_arg_fail(2)) SWIG_fail;
11214 }
11215 }
11216 if (obj2) {
11217 {
11218 arg3 = (int)(SWIG_As_int(obj2));
11219 if (SWIG_arg_fail(3)) SWIG_fail;
11220 }
11221 }
11222 {
11223 PyThreadState* __tstate = wxPyBeginAllowThreads();
11224 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11225
11226 wxPyEndAllowThreads(__tstate);
11227 if (PyErr_Occurred()) SWIG_fail;
11228 }
11229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11237 PyObject *resultobj;
11238 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11239 int result;
11240 PyObject * obj0 = 0 ;
11241 char *kwnames[] = {
11242 (char *) "self", NULL
11243 };
11244
11245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11247 if (SWIG_arg_fail(1)) SWIG_fail;
11248 {
11249 PyThreadState* __tstate = wxPyBeginAllowThreads();
11250 result = (int)(arg1)->GetPid();
11251
11252 wxPyEndAllowThreads(__tstate);
11253 if (PyErr_Occurred()) SWIG_fail;
11254 }
11255 {
11256 resultobj = SWIG_From_int((int)(result));
11257 }
11258 return resultobj;
11259 fail:
11260 return NULL;
11261 }
11262
11263
11264 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj;
11266 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11267 int result;
11268 PyObject * obj0 = 0 ;
11269 char *kwnames[] = {
11270 (char *) "self", NULL
11271 };
11272
11273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11275 if (SWIG_arg_fail(1)) SWIG_fail;
11276 {
11277 PyThreadState* __tstate = wxPyBeginAllowThreads();
11278 result = (int)(arg1)->GetExitCode();
11279
11280 wxPyEndAllowThreads(__tstate);
11281 if (PyErr_Occurred()) SWIG_fail;
11282 }
11283 {
11284 resultobj = SWIG_From_int((int)(result));
11285 }
11286 return resultobj;
11287 fail:
11288 return NULL;
11289 }
11290
11291
11292 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11293 PyObject *resultobj;
11294 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11295 int arg2 ;
11296 PyObject * obj0 = 0 ;
11297 PyObject * obj1 = 0 ;
11298 char *kwnames[] = {
11299 (char *) "self",(char *) "m_pid", NULL
11300 };
11301
11302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11304 if (SWIG_arg_fail(1)) SWIG_fail;
11305 {
11306 arg2 = (int)(SWIG_As_int(obj1));
11307 if (SWIG_arg_fail(2)) SWIG_fail;
11308 }
11309 if (arg1) (arg1)->m_pid = arg2;
11310
11311 Py_INCREF(Py_None); resultobj = Py_None;
11312 return resultobj;
11313 fail:
11314 return NULL;
11315 }
11316
11317
11318 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11319 PyObject *resultobj;
11320 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11321 int result;
11322 PyObject * obj0 = 0 ;
11323 char *kwnames[] = {
11324 (char *) "self", NULL
11325 };
11326
11327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11329 if (SWIG_arg_fail(1)) SWIG_fail;
11330 result = (int) ((arg1)->m_pid);
11331
11332 {
11333 resultobj = SWIG_From_int((int)(result));
11334 }
11335 return resultobj;
11336 fail:
11337 return NULL;
11338 }
11339
11340
11341 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj;
11343 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11344 int arg2 ;
11345 PyObject * obj0 = 0 ;
11346 PyObject * obj1 = 0 ;
11347 char *kwnames[] = {
11348 (char *) "self",(char *) "m_exitcode", NULL
11349 };
11350
11351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11353 if (SWIG_arg_fail(1)) SWIG_fail;
11354 {
11355 arg2 = (int)(SWIG_As_int(obj1));
11356 if (SWIG_arg_fail(2)) SWIG_fail;
11357 }
11358 if (arg1) (arg1)->m_exitcode = arg2;
11359
11360 Py_INCREF(Py_None); resultobj = Py_None;
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11370 int result;
11371 PyObject * obj0 = 0 ;
11372 char *kwnames[] = {
11373 (char *) "self", NULL
11374 };
11375
11376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11378 if (SWIG_arg_fail(1)) SWIG_fail;
11379 result = (int) ((arg1)->m_exitcode);
11380
11381 {
11382 resultobj = SWIG_From_int((int)(result));
11383 }
11384 return resultobj;
11385 fail:
11386 return NULL;
11387 }
11388
11389
11390 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11391 PyObject *obj;
11392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11393 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11394 Py_INCREF(obj);
11395 return Py_BuildValue((char *)"");
11396 }
11397 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11398 PyObject *resultobj;
11399 wxString *arg1 = 0 ;
11400 int arg2 = (int) wxEXEC_ASYNC ;
11401 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11402 long result;
11403 bool temp1 = false ;
11404 PyObject * obj0 = 0 ;
11405 PyObject * obj1 = 0 ;
11406 PyObject * obj2 = 0 ;
11407 char *kwnames[] = {
11408 (char *) "command",(char *) "flags",(char *) "process", NULL
11409 };
11410
11411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11412 {
11413 arg1 = wxString_in_helper(obj0);
11414 if (arg1 == NULL) SWIG_fail;
11415 temp1 = true;
11416 }
11417 if (obj1) {
11418 {
11419 arg2 = (int)(SWIG_As_int(obj1));
11420 if (SWIG_arg_fail(2)) SWIG_fail;
11421 }
11422 }
11423 if (obj2) {
11424 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11425 if (SWIG_arg_fail(3)) SWIG_fail;
11426 }
11427 {
11428 if (!wxPyCheckForApp()) SWIG_fail;
11429 PyThreadState* __tstate = wxPyBeginAllowThreads();
11430 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11431
11432 wxPyEndAllowThreads(__tstate);
11433 if (PyErr_Occurred()) SWIG_fail;
11434 }
11435 {
11436 resultobj = SWIG_From_long((long)(result));
11437 }
11438 {
11439 if (temp1)
11440 delete arg1;
11441 }
11442 return resultobj;
11443 fail:
11444 {
11445 if (temp1)
11446 delete arg1;
11447 }
11448 return NULL;
11449 }
11450
11451
11452 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11453 PyObject *resultobj;
11454 long arg1 ;
11455 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11456 wxKillError *arg3 = (wxKillError *) 0 ;
11457 int arg4 = (int) wxKILL_NOCHILDREN ;
11458 int result;
11459 wxKillError temp3 ;
11460 PyObject * obj0 = 0 ;
11461 PyObject * obj1 = 0 ;
11462 PyObject * obj2 = 0 ;
11463 char *kwnames[] = {
11464 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11465 };
11466
11467 {
11468 arg3 = &temp3;
11469 }
11470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11471 {
11472 arg1 = (long)(SWIG_As_long(obj0));
11473 if (SWIG_arg_fail(1)) SWIG_fail;
11474 }
11475 if (obj1) {
11476 {
11477 arg2 = (wxSignal)(SWIG_As_int(obj1));
11478 if (SWIG_arg_fail(2)) SWIG_fail;
11479 }
11480 }
11481 if (obj2) {
11482 {
11483 arg4 = (int)(SWIG_As_int(obj2));
11484 if (SWIG_arg_fail(4)) SWIG_fail;
11485 }
11486 }
11487 {
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11490
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 {
11495 resultobj = SWIG_From_int((int)(result));
11496 }
11497 {
11498 PyObject* o;
11499 o = PyInt_FromLong((long) (*arg3));
11500 resultobj = t_output_helper(resultobj, o);
11501 }
11502 return resultobj;
11503 fail:
11504 return NULL;
11505 }
11506
11507
11508 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11509 PyObject *resultobj;
11510 int arg1 = (int) wxJOYSTICK1 ;
11511 wxJoystick *result;
11512 PyObject * obj0 = 0 ;
11513 char *kwnames[] = {
11514 (char *) "joystick", NULL
11515 };
11516
11517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11518 if (obj0) {
11519 {
11520 arg1 = (int)(SWIG_As_int(obj0));
11521 if (SWIG_arg_fail(1)) SWIG_fail;
11522 }
11523 }
11524 {
11525 if (!wxPyCheckForApp()) SWIG_fail;
11526 PyThreadState* __tstate = wxPyBeginAllowThreads();
11527 result = (wxJoystick *)new wxJoystick(arg1);
11528
11529 wxPyEndAllowThreads(__tstate);
11530 if (PyErr_Occurred()) SWIG_fail;
11531 }
11532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11533 return resultobj;
11534 fail:
11535 return NULL;
11536 }
11537
11538
11539 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11540 PyObject *resultobj;
11541 wxJoystick *arg1 = (wxJoystick *) 0 ;
11542 PyObject * obj0 = 0 ;
11543 char *kwnames[] = {
11544 (char *) "self", NULL
11545 };
11546
11547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11549 if (SWIG_arg_fail(1)) SWIG_fail;
11550 {
11551 PyThreadState* __tstate = wxPyBeginAllowThreads();
11552 delete arg1;
11553
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 Py_INCREF(Py_None); resultobj = Py_None;
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11565 PyObject *resultobj;
11566 wxJoystick *arg1 = (wxJoystick *) 0 ;
11567 wxPoint result;
11568 PyObject * obj0 = 0 ;
11569 char *kwnames[] = {
11570 (char *) "self", NULL
11571 };
11572
11573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11575 if (SWIG_arg_fail(1)) SWIG_fail;
11576 {
11577 PyThreadState* __tstate = wxPyBeginAllowThreads();
11578 result = (arg1)->GetPosition();
11579
11580 wxPyEndAllowThreads(__tstate);
11581 if (PyErr_Occurred()) SWIG_fail;
11582 }
11583 {
11584 wxPoint * resultptr;
11585 resultptr = new wxPoint((wxPoint &)(result));
11586 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11587 }
11588 return resultobj;
11589 fail:
11590 return NULL;
11591 }
11592
11593
11594 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11595 PyObject *resultobj;
11596 wxJoystick *arg1 = (wxJoystick *) 0 ;
11597 int result;
11598 PyObject * obj0 = 0 ;
11599 char *kwnames[] = {
11600 (char *) "self", NULL
11601 };
11602
11603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11605 if (SWIG_arg_fail(1)) SWIG_fail;
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (int)(arg1)->GetZPosition();
11609
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = SWIG_From_int((int)(result));
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj;
11624 wxJoystick *arg1 = (wxJoystick *) 0 ;
11625 int result;
11626 PyObject * obj0 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "self", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11633 if (SWIG_arg_fail(1)) SWIG_fail;
11634 {
11635 PyThreadState* __tstate = wxPyBeginAllowThreads();
11636 result = (int)(arg1)->GetButtonState();
11637
11638 wxPyEndAllowThreads(__tstate);
11639 if (PyErr_Occurred()) SWIG_fail;
11640 }
11641 {
11642 resultobj = SWIG_From_int((int)(result));
11643 }
11644 return resultobj;
11645 fail:
11646 return NULL;
11647 }
11648
11649
11650 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11651 PyObject *resultobj;
11652 wxJoystick *arg1 = (wxJoystick *) 0 ;
11653 int result;
11654 PyObject * obj0 = 0 ;
11655 char *kwnames[] = {
11656 (char *) "self", NULL
11657 };
11658
11659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11661 if (SWIG_arg_fail(1)) SWIG_fail;
11662 {
11663 PyThreadState* __tstate = wxPyBeginAllowThreads();
11664 result = (int)(arg1)->GetPOVPosition();
11665
11666 wxPyEndAllowThreads(__tstate);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 {
11670 resultobj = SWIG_From_int((int)(result));
11671 }
11672 return resultobj;
11673 fail:
11674 return NULL;
11675 }
11676
11677
11678 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11679 PyObject *resultobj;
11680 wxJoystick *arg1 = (wxJoystick *) 0 ;
11681 int result;
11682 PyObject * obj0 = 0 ;
11683 char *kwnames[] = {
11684 (char *) "self", NULL
11685 };
11686
11687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11689 if (SWIG_arg_fail(1)) SWIG_fail;
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (int)(arg1)->GetPOVCTSPosition();
11693
11694 wxPyEndAllowThreads(__tstate);
11695 if (PyErr_Occurred()) SWIG_fail;
11696 }
11697 {
11698 resultobj = SWIG_From_int((int)(result));
11699 }
11700 return resultobj;
11701 fail:
11702 return NULL;
11703 }
11704
11705
11706 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11707 PyObject *resultobj;
11708 wxJoystick *arg1 = (wxJoystick *) 0 ;
11709 int result;
11710 PyObject * obj0 = 0 ;
11711 char *kwnames[] = {
11712 (char *) "self", NULL
11713 };
11714
11715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11717 if (SWIG_arg_fail(1)) SWIG_fail;
11718 {
11719 PyThreadState* __tstate = wxPyBeginAllowThreads();
11720 result = (int)(arg1)->GetRudderPosition();
11721
11722 wxPyEndAllowThreads(__tstate);
11723 if (PyErr_Occurred()) SWIG_fail;
11724 }
11725 {
11726 resultobj = SWIG_From_int((int)(result));
11727 }
11728 return resultobj;
11729 fail:
11730 return NULL;
11731 }
11732
11733
11734 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11735 PyObject *resultobj;
11736 wxJoystick *arg1 = (wxJoystick *) 0 ;
11737 int result;
11738 PyObject * obj0 = 0 ;
11739 char *kwnames[] = {
11740 (char *) "self", NULL
11741 };
11742
11743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11745 if (SWIG_arg_fail(1)) SWIG_fail;
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (int)(arg1)->GetUPosition();
11749
11750 wxPyEndAllowThreads(__tstate);
11751 if (PyErr_Occurred()) SWIG_fail;
11752 }
11753 {
11754 resultobj = SWIG_From_int((int)(result));
11755 }
11756 return resultobj;
11757 fail:
11758 return NULL;
11759 }
11760
11761
11762 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11763 PyObject *resultobj;
11764 wxJoystick *arg1 = (wxJoystick *) 0 ;
11765 int result;
11766 PyObject * obj0 = 0 ;
11767 char *kwnames[] = {
11768 (char *) "self", NULL
11769 };
11770
11771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11773 if (SWIG_arg_fail(1)) SWIG_fail;
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 result = (int)(arg1)->GetVPosition();
11777
11778 wxPyEndAllowThreads(__tstate);
11779 if (PyErr_Occurred()) SWIG_fail;
11780 }
11781 {
11782 resultobj = SWIG_From_int((int)(result));
11783 }
11784 return resultobj;
11785 fail:
11786 return NULL;
11787 }
11788
11789
11790 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11791 PyObject *resultobj;
11792 wxJoystick *arg1 = (wxJoystick *) 0 ;
11793 int result;
11794 PyObject * obj0 = 0 ;
11795 char *kwnames[] = {
11796 (char *) "self", NULL
11797 };
11798
11799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11801 if (SWIG_arg_fail(1)) SWIG_fail;
11802 {
11803 PyThreadState* __tstate = wxPyBeginAllowThreads();
11804 result = (int)(arg1)->GetMovementThreshold();
11805
11806 wxPyEndAllowThreads(__tstate);
11807 if (PyErr_Occurred()) SWIG_fail;
11808 }
11809 {
11810 resultobj = SWIG_From_int((int)(result));
11811 }
11812 return resultobj;
11813 fail:
11814 return NULL;
11815 }
11816
11817
11818 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11819 PyObject *resultobj;
11820 wxJoystick *arg1 = (wxJoystick *) 0 ;
11821 int arg2 ;
11822 PyObject * obj0 = 0 ;
11823 PyObject * obj1 = 0 ;
11824 char *kwnames[] = {
11825 (char *) "self",(char *) "threshold", NULL
11826 };
11827
11828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11830 if (SWIG_arg_fail(1)) SWIG_fail;
11831 {
11832 arg2 = (int)(SWIG_As_int(obj1));
11833 if (SWIG_arg_fail(2)) SWIG_fail;
11834 }
11835 {
11836 PyThreadState* __tstate = wxPyBeginAllowThreads();
11837 (arg1)->SetMovementThreshold(arg2);
11838
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 Py_INCREF(Py_None); resultobj = Py_None;
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11850 PyObject *resultobj;
11851 wxJoystick *arg1 = (wxJoystick *) 0 ;
11852 bool result;
11853 PyObject * obj0 = 0 ;
11854 char *kwnames[] = {
11855 (char *) "self", NULL
11856 };
11857
11858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11860 if (SWIG_arg_fail(1)) SWIG_fail;
11861 {
11862 PyThreadState* __tstate = wxPyBeginAllowThreads();
11863 result = (bool)(arg1)->IsOk();
11864
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11870 }
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11878 PyObject *resultobj;
11879 wxJoystick *arg1 = (wxJoystick *) 0 ;
11880 int result;
11881 PyObject * obj0 = 0 ;
11882 char *kwnames[] = {
11883 (char *) "self", NULL
11884 };
11885
11886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11888 if (SWIG_arg_fail(1)) SWIG_fail;
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (int)(arg1)->GetNumberJoysticks();
11892
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 {
11897 resultobj = SWIG_From_int((int)(result));
11898 }
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj;
11907 wxJoystick *arg1 = (wxJoystick *) 0 ;
11908 int result;
11909 PyObject * obj0 = 0 ;
11910 char *kwnames[] = {
11911 (char *) "self", NULL
11912 };
11913
11914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11916 if (SWIG_arg_fail(1)) SWIG_fail;
11917 {
11918 PyThreadState* __tstate = wxPyBeginAllowThreads();
11919 result = (int)(arg1)->GetManufacturerId();
11920
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 resultobj = SWIG_From_int((int)(result));
11926 }
11927 return resultobj;
11928 fail:
11929 return NULL;
11930 }
11931
11932
11933 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj;
11935 wxJoystick *arg1 = (wxJoystick *) 0 ;
11936 int result;
11937 PyObject * obj0 = 0 ;
11938 char *kwnames[] = {
11939 (char *) "self", NULL
11940 };
11941
11942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11944 if (SWIG_arg_fail(1)) SWIG_fail;
11945 {
11946 PyThreadState* __tstate = wxPyBeginAllowThreads();
11947 result = (int)(arg1)->GetProductId();
11948
11949 wxPyEndAllowThreads(__tstate);
11950 if (PyErr_Occurred()) SWIG_fail;
11951 }
11952 {
11953 resultobj = SWIG_From_int((int)(result));
11954 }
11955 return resultobj;
11956 fail:
11957 return NULL;
11958 }
11959
11960
11961 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11962 PyObject *resultobj;
11963 wxJoystick *arg1 = (wxJoystick *) 0 ;
11964 wxString result;
11965 PyObject * obj0 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 PyThreadState* __tstate = wxPyBeginAllowThreads();
11975 result = (arg1)->GetProductName();
11976
11977 wxPyEndAllowThreads(__tstate);
11978 if (PyErr_Occurred()) SWIG_fail;
11979 }
11980 {
11981 #if wxUSE_UNICODE
11982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11983 #else
11984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11985 #endif
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj;
11995 wxJoystick *arg1 = (wxJoystick *) 0 ;
11996 int result;
11997 PyObject * obj0 = 0 ;
11998 char *kwnames[] = {
11999 (char *) "self", NULL
12000 };
12001
12002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12004 if (SWIG_arg_fail(1)) SWIG_fail;
12005 {
12006 PyThreadState* __tstate = wxPyBeginAllowThreads();
12007 result = (int)(arg1)->GetXMin();
12008
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = SWIG_From_int((int)(result));
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj;
12023 wxJoystick *arg1 = (wxJoystick *) 0 ;
12024 int result;
12025 PyObject * obj0 = 0 ;
12026 char *kwnames[] = {
12027 (char *) "self", NULL
12028 };
12029
12030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12032 if (SWIG_arg_fail(1)) SWIG_fail;
12033 {
12034 PyThreadState* __tstate = wxPyBeginAllowThreads();
12035 result = (int)(arg1)->GetYMin();
12036
12037 wxPyEndAllowThreads(__tstate);
12038 if (PyErr_Occurred()) SWIG_fail;
12039 }
12040 {
12041 resultobj = SWIG_From_int((int)(result));
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12050 PyObject *resultobj;
12051 wxJoystick *arg1 = (wxJoystick *) 0 ;
12052 int result;
12053 PyObject * obj0 = 0 ;
12054 char *kwnames[] = {
12055 (char *) "self", NULL
12056 };
12057
12058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12060 if (SWIG_arg_fail(1)) SWIG_fail;
12061 {
12062 PyThreadState* __tstate = wxPyBeginAllowThreads();
12063 result = (int)(arg1)->GetZMin();
12064
12065 wxPyEndAllowThreads(__tstate);
12066 if (PyErr_Occurred()) SWIG_fail;
12067 }
12068 {
12069 resultobj = SWIG_From_int((int)(result));
12070 }
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12078 PyObject *resultobj;
12079 wxJoystick *arg1 = (wxJoystick *) 0 ;
12080 int result;
12081 PyObject * obj0 = 0 ;
12082 char *kwnames[] = {
12083 (char *) "self", NULL
12084 };
12085
12086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12088 if (SWIG_arg_fail(1)) SWIG_fail;
12089 {
12090 PyThreadState* __tstate = wxPyBeginAllowThreads();
12091 result = (int)(arg1)->GetXMax();
12092
12093 wxPyEndAllowThreads(__tstate);
12094 if (PyErr_Occurred()) SWIG_fail;
12095 }
12096 {
12097 resultobj = SWIG_From_int((int)(result));
12098 }
12099 return resultobj;
12100 fail:
12101 return NULL;
12102 }
12103
12104
12105 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12106 PyObject *resultobj;
12107 wxJoystick *arg1 = (wxJoystick *) 0 ;
12108 int result;
12109 PyObject * obj0 = 0 ;
12110 char *kwnames[] = {
12111 (char *) "self", NULL
12112 };
12113
12114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12116 if (SWIG_arg_fail(1)) SWIG_fail;
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (int)(arg1)->GetYMax();
12120
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = SWIG_From_int((int)(result));
12126 }
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj;
12135 wxJoystick *arg1 = (wxJoystick *) 0 ;
12136 int result;
12137 PyObject * obj0 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (int)(arg1)->GetZMax();
12148
12149 wxPyEndAllowThreads(__tstate);
12150 if (PyErr_Occurred()) SWIG_fail;
12151 }
12152 {
12153 resultobj = SWIG_From_int((int)(result));
12154 }
12155 return resultobj;
12156 fail:
12157 return NULL;
12158 }
12159
12160
12161 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12162 PyObject *resultobj;
12163 wxJoystick *arg1 = (wxJoystick *) 0 ;
12164 int result;
12165 PyObject * obj0 = 0 ;
12166 char *kwnames[] = {
12167 (char *) "self", NULL
12168 };
12169
12170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12172 if (SWIG_arg_fail(1)) SWIG_fail;
12173 {
12174 PyThreadState* __tstate = wxPyBeginAllowThreads();
12175 result = (int)(arg1)->GetNumberButtons();
12176
12177 wxPyEndAllowThreads(__tstate);
12178 if (PyErr_Occurred()) SWIG_fail;
12179 }
12180 {
12181 resultobj = SWIG_From_int((int)(result));
12182 }
12183 return resultobj;
12184 fail:
12185 return NULL;
12186 }
12187
12188
12189 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12190 PyObject *resultobj;
12191 wxJoystick *arg1 = (wxJoystick *) 0 ;
12192 int result;
12193 PyObject * obj0 = 0 ;
12194 char *kwnames[] = {
12195 (char *) "self", NULL
12196 };
12197
12198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12200 if (SWIG_arg_fail(1)) SWIG_fail;
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (int)(arg1)->GetNumberAxes();
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 {
12209 resultobj = SWIG_From_int((int)(result));
12210 }
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj;
12219 wxJoystick *arg1 = (wxJoystick *) 0 ;
12220 int result;
12221 PyObject * obj0 = 0 ;
12222 char *kwnames[] = {
12223 (char *) "self", NULL
12224 };
12225
12226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12228 if (SWIG_arg_fail(1)) SWIG_fail;
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (int)(arg1)->GetMaxButtons();
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = SWIG_From_int((int)(result));
12238 }
12239 return resultobj;
12240 fail:
12241 return NULL;
12242 }
12243
12244
12245 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12246 PyObject *resultobj;
12247 wxJoystick *arg1 = (wxJoystick *) 0 ;
12248 int result;
12249 PyObject * obj0 = 0 ;
12250 char *kwnames[] = {
12251 (char *) "self", NULL
12252 };
12253
12254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12256 if (SWIG_arg_fail(1)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (int)(arg1)->GetMaxAxes();
12260
12261 wxPyEndAllowThreads(__tstate);
12262 if (PyErr_Occurred()) SWIG_fail;
12263 }
12264 {
12265 resultobj = SWIG_From_int((int)(result));
12266 }
12267 return resultobj;
12268 fail:
12269 return NULL;
12270 }
12271
12272
12273 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12274 PyObject *resultobj;
12275 wxJoystick *arg1 = (wxJoystick *) 0 ;
12276 int result;
12277 PyObject * obj0 = 0 ;
12278 char *kwnames[] = {
12279 (char *) "self", NULL
12280 };
12281
12282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12284 if (SWIG_arg_fail(1)) SWIG_fail;
12285 {
12286 PyThreadState* __tstate = wxPyBeginAllowThreads();
12287 result = (int)(arg1)->GetPollingMin();
12288
12289 wxPyEndAllowThreads(__tstate);
12290 if (PyErr_Occurred()) SWIG_fail;
12291 }
12292 {
12293 resultobj = SWIG_From_int((int)(result));
12294 }
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj;
12303 wxJoystick *arg1 = (wxJoystick *) 0 ;
12304 int result;
12305 PyObject * obj0 = 0 ;
12306 char *kwnames[] = {
12307 (char *) "self", NULL
12308 };
12309
12310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12312 if (SWIG_arg_fail(1)) SWIG_fail;
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (int)(arg1)->GetPollingMax();
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = SWIG_From_int((int)(result));
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj;
12331 wxJoystick *arg1 = (wxJoystick *) 0 ;
12332 int result;
12333 PyObject * obj0 = 0 ;
12334 char *kwnames[] = {
12335 (char *) "self", NULL
12336 };
12337
12338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12340 if (SWIG_arg_fail(1)) SWIG_fail;
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (int)(arg1)->GetRudderMin();
12344
12345 wxPyEndAllowThreads(__tstate);
12346 if (PyErr_Occurred()) SWIG_fail;
12347 }
12348 {
12349 resultobj = SWIG_From_int((int)(result));
12350 }
12351 return resultobj;
12352 fail:
12353 return NULL;
12354 }
12355
12356
12357 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12358 PyObject *resultobj;
12359 wxJoystick *arg1 = (wxJoystick *) 0 ;
12360 int result;
12361 PyObject * obj0 = 0 ;
12362 char *kwnames[] = {
12363 (char *) "self", NULL
12364 };
12365
12366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(1)) SWIG_fail;
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (int)(arg1)->GetRudderMax();
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = SWIG_From_int((int)(result));
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj;
12387 wxJoystick *arg1 = (wxJoystick *) 0 ;
12388 int result;
12389 PyObject * obj0 = 0 ;
12390 char *kwnames[] = {
12391 (char *) "self", NULL
12392 };
12393
12394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12396 if (SWIG_arg_fail(1)) SWIG_fail;
12397 {
12398 PyThreadState* __tstate = wxPyBeginAllowThreads();
12399 result = (int)(arg1)->GetUMin();
12400
12401 wxPyEndAllowThreads(__tstate);
12402 if (PyErr_Occurred()) SWIG_fail;
12403 }
12404 {
12405 resultobj = SWIG_From_int((int)(result));
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxJoystick *arg1 = (wxJoystick *) 0 ;
12416 int result;
12417 PyObject * obj0 = 0 ;
12418 char *kwnames[] = {
12419 (char *) "self", NULL
12420 };
12421
12422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12424 if (SWIG_arg_fail(1)) SWIG_fail;
12425 {
12426 PyThreadState* __tstate = wxPyBeginAllowThreads();
12427 result = (int)(arg1)->GetUMax();
12428
12429 wxPyEndAllowThreads(__tstate);
12430 if (PyErr_Occurred()) SWIG_fail;
12431 }
12432 {
12433 resultobj = SWIG_From_int((int)(result));
12434 }
12435 return resultobj;
12436 fail:
12437 return NULL;
12438 }
12439
12440
12441 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12442 PyObject *resultobj;
12443 wxJoystick *arg1 = (wxJoystick *) 0 ;
12444 int result;
12445 PyObject * obj0 = 0 ;
12446 char *kwnames[] = {
12447 (char *) "self", NULL
12448 };
12449
12450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12452 if (SWIG_arg_fail(1)) SWIG_fail;
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (int)(arg1)->GetVMin();
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = SWIG_From_int((int)(result));
12462 }
12463 return resultobj;
12464 fail:
12465 return NULL;
12466 }
12467
12468
12469 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12470 PyObject *resultobj;
12471 wxJoystick *arg1 = (wxJoystick *) 0 ;
12472 int result;
12473 PyObject * obj0 = 0 ;
12474 char *kwnames[] = {
12475 (char *) "self", NULL
12476 };
12477
12478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12480 if (SWIG_arg_fail(1)) SWIG_fail;
12481 {
12482 PyThreadState* __tstate = wxPyBeginAllowThreads();
12483 result = (int)(arg1)->GetVMax();
12484
12485 wxPyEndAllowThreads(__tstate);
12486 if (PyErr_Occurred()) SWIG_fail;
12487 }
12488 {
12489 resultobj = SWIG_From_int((int)(result));
12490 }
12491 return resultobj;
12492 fail:
12493 return NULL;
12494 }
12495
12496
12497 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12498 PyObject *resultobj;
12499 wxJoystick *arg1 = (wxJoystick *) 0 ;
12500 bool result;
12501 PyObject * obj0 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (bool)(arg1)->HasRudder();
12512
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12518 }
12519 return resultobj;
12520 fail:
12521 return NULL;
12522 }
12523
12524
12525 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12526 PyObject *resultobj;
12527 wxJoystick *arg1 = (wxJoystick *) 0 ;
12528 bool result;
12529 PyObject * obj0 = 0 ;
12530 char *kwnames[] = {
12531 (char *) "self", NULL
12532 };
12533
12534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12536 if (SWIG_arg_fail(1)) SWIG_fail;
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 result = (bool)(arg1)->HasZ();
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 {
12545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12546 }
12547 return resultobj;
12548 fail:
12549 return NULL;
12550 }
12551
12552
12553 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12554 PyObject *resultobj;
12555 wxJoystick *arg1 = (wxJoystick *) 0 ;
12556 bool result;
12557 PyObject * obj0 = 0 ;
12558 char *kwnames[] = {
12559 (char *) "self", NULL
12560 };
12561
12562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(1)) SWIG_fail;
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 result = (bool)(arg1)->HasU();
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 {
12573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12574 }
12575 return resultobj;
12576 fail:
12577 return NULL;
12578 }
12579
12580
12581 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj;
12583 wxJoystick *arg1 = (wxJoystick *) 0 ;
12584 bool result;
12585 PyObject * obj0 = 0 ;
12586 char *kwnames[] = {
12587 (char *) "self", NULL
12588 };
12589
12590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12592 if (SWIG_arg_fail(1)) SWIG_fail;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 result = (bool)(arg1)->HasV();
12596
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 {
12601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12602 }
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12610 PyObject *resultobj;
12611 wxJoystick *arg1 = (wxJoystick *) 0 ;
12612 bool result;
12613 PyObject * obj0 = 0 ;
12614 char *kwnames[] = {
12615 (char *) "self", NULL
12616 };
12617
12618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12620 if (SWIG_arg_fail(1)) SWIG_fail;
12621 {
12622 PyThreadState* __tstate = wxPyBeginAllowThreads();
12623 result = (bool)(arg1)->HasPOV();
12624
12625 wxPyEndAllowThreads(__tstate);
12626 if (PyErr_Occurred()) SWIG_fail;
12627 }
12628 {
12629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12630 }
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12638 PyObject *resultobj;
12639 wxJoystick *arg1 = (wxJoystick *) 0 ;
12640 bool result;
12641 PyObject * obj0 = 0 ;
12642 char *kwnames[] = {
12643 (char *) "self", NULL
12644 };
12645
12646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12648 if (SWIG_arg_fail(1)) SWIG_fail;
12649 {
12650 PyThreadState* __tstate = wxPyBeginAllowThreads();
12651 result = (bool)(arg1)->HasPOV4Dir();
12652
12653 wxPyEndAllowThreads(__tstate);
12654 if (PyErr_Occurred()) SWIG_fail;
12655 }
12656 {
12657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12658 }
12659 return resultobj;
12660 fail:
12661 return NULL;
12662 }
12663
12664
12665 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12666 PyObject *resultobj;
12667 wxJoystick *arg1 = (wxJoystick *) 0 ;
12668 bool result;
12669 PyObject * obj0 = 0 ;
12670 char *kwnames[] = {
12671 (char *) "self", NULL
12672 };
12673
12674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12676 if (SWIG_arg_fail(1)) SWIG_fail;
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 result = (bool)(arg1)->HasPOVCTS();
12680
12681 wxPyEndAllowThreads(__tstate);
12682 if (PyErr_Occurred()) SWIG_fail;
12683 }
12684 {
12685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12686 }
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj;
12695 wxJoystick *arg1 = (wxJoystick *) 0 ;
12696 wxWindow *arg2 = (wxWindow *) 0 ;
12697 int arg3 = (int) 0 ;
12698 bool result;
12699 PyObject * obj0 = 0 ;
12700 PyObject * obj1 = 0 ;
12701 PyObject * obj2 = 0 ;
12702 char *kwnames[] = {
12703 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12704 };
12705
12706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12708 if (SWIG_arg_fail(1)) SWIG_fail;
12709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12710 if (SWIG_arg_fail(2)) SWIG_fail;
12711 if (obj2) {
12712 {
12713 arg3 = (int)(SWIG_As_int(obj2));
12714 if (SWIG_arg_fail(3)) SWIG_fail;
12715 }
12716 }
12717 {
12718 PyThreadState* __tstate = wxPyBeginAllowThreads();
12719 result = (bool)(arg1)->SetCapture(arg2,arg3);
12720
12721 wxPyEndAllowThreads(__tstate);
12722 if (PyErr_Occurred()) SWIG_fail;
12723 }
12724 {
12725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12726 }
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12734 PyObject *resultobj;
12735 wxJoystick *arg1 = (wxJoystick *) 0 ;
12736 bool result;
12737 PyObject * obj0 = 0 ;
12738 char *kwnames[] = {
12739 (char *) "self", NULL
12740 };
12741
12742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12744 if (SWIG_arg_fail(1)) SWIG_fail;
12745 {
12746 PyThreadState* __tstate = wxPyBeginAllowThreads();
12747 result = (bool)(arg1)->ReleaseCapture();
12748
12749 wxPyEndAllowThreads(__tstate);
12750 if (PyErr_Occurred()) SWIG_fail;
12751 }
12752 {
12753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12754 }
12755 return resultobj;
12756 fail:
12757 return NULL;
12758 }
12759
12760
12761 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12762 PyObject *obj;
12763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12764 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12765 Py_INCREF(obj);
12766 return Py_BuildValue((char *)"");
12767 }
12768 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12769 PyObject *resultobj;
12770 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12771 int arg2 = (int) 0 ;
12772 int arg3 = (int) wxJOYSTICK1 ;
12773 int arg4 = (int) 0 ;
12774 wxJoystickEvent *result;
12775 PyObject * obj0 = 0 ;
12776 PyObject * obj1 = 0 ;
12777 PyObject * obj2 = 0 ;
12778 PyObject * obj3 = 0 ;
12779 char *kwnames[] = {
12780 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12781 };
12782
12783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12784 if (obj0) {
12785 {
12786 arg1 = (wxEventType)(SWIG_As_int(obj0));
12787 if (SWIG_arg_fail(1)) SWIG_fail;
12788 }
12789 }
12790 if (obj1) {
12791 {
12792 arg2 = (int)(SWIG_As_int(obj1));
12793 if (SWIG_arg_fail(2)) SWIG_fail;
12794 }
12795 }
12796 if (obj2) {
12797 {
12798 arg3 = (int)(SWIG_As_int(obj2));
12799 if (SWIG_arg_fail(3)) SWIG_fail;
12800 }
12801 }
12802 if (obj3) {
12803 {
12804 arg4 = (int)(SWIG_As_int(obj3));
12805 if (SWIG_arg_fail(4)) SWIG_fail;
12806 }
12807 }
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12811
12812 wxPyEndAllowThreads(__tstate);
12813 if (PyErr_Occurred()) SWIG_fail;
12814 }
12815 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12816 return resultobj;
12817 fail:
12818 return NULL;
12819 }
12820
12821
12822 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12823 PyObject *resultobj;
12824 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12825 wxPoint result;
12826 PyObject * obj0 = 0 ;
12827 char *kwnames[] = {
12828 (char *) "self", NULL
12829 };
12830
12831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12833 if (SWIG_arg_fail(1)) SWIG_fail;
12834 {
12835 PyThreadState* __tstate = wxPyBeginAllowThreads();
12836 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12837
12838 wxPyEndAllowThreads(__tstate);
12839 if (PyErr_Occurred()) SWIG_fail;
12840 }
12841 {
12842 wxPoint * resultptr;
12843 resultptr = new wxPoint((wxPoint &)(result));
12844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12845 }
12846 return resultobj;
12847 fail:
12848 return NULL;
12849 }
12850
12851
12852 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12853 PyObject *resultobj;
12854 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12855 int result;
12856 PyObject * obj0 = 0 ;
12857 char *kwnames[] = {
12858 (char *) "self", NULL
12859 };
12860
12861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12863 if (SWIG_arg_fail(1)) SWIG_fail;
12864 {
12865 PyThreadState* __tstate = wxPyBeginAllowThreads();
12866 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12867
12868 wxPyEndAllowThreads(__tstate);
12869 if (PyErr_Occurred()) SWIG_fail;
12870 }
12871 {
12872 resultobj = SWIG_From_int((int)(result));
12873 }
12874 return resultobj;
12875 fail:
12876 return NULL;
12877 }
12878
12879
12880 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12881 PyObject *resultobj;
12882 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12883 int result;
12884 PyObject * obj0 = 0 ;
12885 char *kwnames[] = {
12886 (char *) "self", NULL
12887 };
12888
12889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12891 if (SWIG_arg_fail(1)) SWIG_fail;
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12895
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 {
12900 resultobj = SWIG_From_int((int)(result));
12901 }
12902 return resultobj;
12903 fail:
12904 return NULL;
12905 }
12906
12907
12908 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12909 PyObject *resultobj;
12910 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12911 int result;
12912 PyObject * obj0 = 0 ;
12913 char *kwnames[] = {
12914 (char *) "self", NULL
12915 };
12916
12917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12919 if (SWIG_arg_fail(1)) SWIG_fail;
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12923
12924 wxPyEndAllowThreads(__tstate);
12925 if (PyErr_Occurred()) SWIG_fail;
12926 }
12927 {
12928 resultobj = SWIG_From_int((int)(result));
12929 }
12930 return resultobj;
12931 fail:
12932 return NULL;
12933 }
12934
12935
12936 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12937 PyObject *resultobj;
12938 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12939 int result;
12940 PyObject * obj0 = 0 ;
12941 char *kwnames[] = {
12942 (char *) "self", NULL
12943 };
12944
12945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12947 if (SWIG_arg_fail(1)) SWIG_fail;
12948 {
12949 PyThreadState* __tstate = wxPyBeginAllowThreads();
12950 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12951
12952 wxPyEndAllowThreads(__tstate);
12953 if (PyErr_Occurred()) SWIG_fail;
12954 }
12955 {
12956 resultobj = SWIG_From_int((int)(result));
12957 }
12958 return resultobj;
12959 fail:
12960 return NULL;
12961 }
12962
12963
12964 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12965 PyObject *resultobj;
12966 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12967 int arg2 ;
12968 PyObject * obj0 = 0 ;
12969 PyObject * obj1 = 0 ;
12970 char *kwnames[] = {
12971 (char *) "self",(char *) "stick", NULL
12972 };
12973
12974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12976 if (SWIG_arg_fail(1)) SWIG_fail;
12977 {
12978 arg2 = (int)(SWIG_As_int(obj1));
12979 if (SWIG_arg_fail(2)) SWIG_fail;
12980 }
12981 {
12982 PyThreadState* __tstate = wxPyBeginAllowThreads();
12983 (arg1)->SetJoystick(arg2);
12984
12985 wxPyEndAllowThreads(__tstate);
12986 if (PyErr_Occurred()) SWIG_fail;
12987 }
12988 Py_INCREF(Py_None); resultobj = Py_None;
12989 return resultobj;
12990 fail:
12991 return NULL;
12992 }
12993
12994
12995 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12996 PyObject *resultobj;
12997 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12998 int arg2 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 char *kwnames[] = {
13002 (char *) "self",(char *) "state", NULL
13003 };
13004
13005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13007 if (SWIG_arg_fail(1)) SWIG_fail;
13008 {
13009 arg2 = (int)(SWIG_As_int(obj1));
13010 if (SWIG_arg_fail(2)) SWIG_fail;
13011 }
13012 {
13013 PyThreadState* __tstate = wxPyBeginAllowThreads();
13014 (arg1)->SetButtonState(arg2);
13015
13016 wxPyEndAllowThreads(__tstate);
13017 if (PyErr_Occurred()) SWIG_fail;
13018 }
13019 Py_INCREF(Py_None); resultobj = Py_None;
13020 return resultobj;
13021 fail:
13022 return NULL;
13023 }
13024
13025
13026 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13027 PyObject *resultobj;
13028 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13029 int arg2 ;
13030 PyObject * obj0 = 0 ;
13031 PyObject * obj1 = 0 ;
13032 char *kwnames[] = {
13033 (char *) "self",(char *) "change", NULL
13034 };
13035
13036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13038 if (SWIG_arg_fail(1)) SWIG_fail;
13039 {
13040 arg2 = (int)(SWIG_As_int(obj1));
13041 if (SWIG_arg_fail(2)) SWIG_fail;
13042 }
13043 {
13044 PyThreadState* __tstate = wxPyBeginAllowThreads();
13045 (arg1)->SetButtonChange(arg2);
13046
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 Py_INCREF(Py_None); resultobj = Py_None;
13051 return resultobj;
13052 fail:
13053 return NULL;
13054 }
13055
13056
13057 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13058 PyObject *resultobj;
13059 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13060 wxPoint *arg2 = 0 ;
13061 wxPoint temp2 ;
13062 PyObject * obj0 = 0 ;
13063 PyObject * obj1 = 0 ;
13064 char *kwnames[] = {
13065 (char *) "self",(char *) "pos", NULL
13066 };
13067
13068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13070 if (SWIG_arg_fail(1)) SWIG_fail;
13071 {
13072 arg2 = &temp2;
13073 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 (arg1)->SetPosition((wxPoint const &)*arg2);
13078
13079 wxPyEndAllowThreads(__tstate);
13080 if (PyErr_Occurred()) SWIG_fail;
13081 }
13082 Py_INCREF(Py_None); resultobj = Py_None;
13083 return resultobj;
13084 fail:
13085 return NULL;
13086 }
13087
13088
13089 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13090 PyObject *resultobj;
13091 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13092 int arg2 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 char *kwnames[] = {
13096 (char *) "self",(char *) "zPos", NULL
13097 };
13098
13099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13101 if (SWIG_arg_fail(1)) SWIG_fail;
13102 {
13103 arg2 = (int)(SWIG_As_int(obj1));
13104 if (SWIG_arg_fail(2)) SWIG_fail;
13105 }
13106 {
13107 PyThreadState* __tstate = wxPyBeginAllowThreads();
13108 (arg1)->SetZPosition(arg2);
13109
13110 wxPyEndAllowThreads(__tstate);
13111 if (PyErr_Occurred()) SWIG_fail;
13112 }
13113 Py_INCREF(Py_None); resultobj = Py_None;
13114 return resultobj;
13115 fail:
13116 return NULL;
13117 }
13118
13119
13120 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13121 PyObject *resultobj;
13122 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13123 bool result;
13124 PyObject * obj0 = 0 ;
13125 char *kwnames[] = {
13126 (char *) "self", NULL
13127 };
13128
13129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13131 if (SWIG_arg_fail(1)) SWIG_fail;
13132 {
13133 PyThreadState* __tstate = wxPyBeginAllowThreads();
13134 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13135
13136 wxPyEndAllowThreads(__tstate);
13137 if (PyErr_Occurred()) SWIG_fail;
13138 }
13139 {
13140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13141 }
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj;
13150 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13151 bool result;
13152 PyObject * obj0 = 0 ;
13153 char *kwnames[] = {
13154 (char *) "self", NULL
13155 };
13156
13157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13159 if (SWIG_arg_fail(1)) SWIG_fail;
13160 {
13161 PyThreadState* __tstate = wxPyBeginAllowThreads();
13162 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13163
13164 wxPyEndAllowThreads(__tstate);
13165 if (PyErr_Occurred()) SWIG_fail;
13166 }
13167 {
13168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13169 }
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj;
13178 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13179 bool result;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "self", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 {
13196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13197 }
13198 return resultobj;
13199 fail:
13200 return NULL;
13201 }
13202
13203
13204 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13205 PyObject *resultobj;
13206 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13207 int arg2 = (int) wxJOY_BUTTON_ANY ;
13208 bool result;
13209 PyObject * obj0 = 0 ;
13210 PyObject * obj1 = 0 ;
13211 char *kwnames[] = {
13212 (char *) "self",(char *) "but", NULL
13213 };
13214
13215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13217 if (SWIG_arg_fail(1)) SWIG_fail;
13218 if (obj1) {
13219 {
13220 arg2 = (int)(SWIG_As_int(obj1));
13221 if (SWIG_arg_fail(2)) SWIG_fail;
13222 }
13223 }
13224 {
13225 PyThreadState* __tstate = wxPyBeginAllowThreads();
13226 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13227
13228 wxPyEndAllowThreads(__tstate);
13229 if (PyErr_Occurred()) SWIG_fail;
13230 }
13231 {
13232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13233 }
13234 return resultobj;
13235 fail:
13236 return NULL;
13237 }
13238
13239
13240 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13241 PyObject *resultobj;
13242 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13243 int arg2 = (int) wxJOY_BUTTON_ANY ;
13244 bool result;
13245 PyObject * obj0 = 0 ;
13246 PyObject * obj1 = 0 ;
13247 char *kwnames[] = {
13248 (char *) "self",(char *) "but", NULL
13249 };
13250
13251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13253 if (SWIG_arg_fail(1)) SWIG_fail;
13254 if (obj1) {
13255 {
13256 arg2 = (int)(SWIG_As_int(obj1));
13257 if (SWIG_arg_fail(2)) SWIG_fail;
13258 }
13259 }
13260 {
13261 PyThreadState* __tstate = wxPyBeginAllowThreads();
13262 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13263
13264 wxPyEndAllowThreads(__tstate);
13265 if (PyErr_Occurred()) SWIG_fail;
13266 }
13267 {
13268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13269 }
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj;
13278 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13279 int arg2 = (int) wxJOY_BUTTON_ANY ;
13280 bool result;
13281 PyObject * obj0 = 0 ;
13282 PyObject * obj1 = 0 ;
13283 char *kwnames[] = {
13284 (char *) "self",(char *) "but", NULL
13285 };
13286
13287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13289 if (SWIG_arg_fail(1)) SWIG_fail;
13290 if (obj1) {
13291 {
13292 arg2 = (int)(SWIG_As_int(obj1));
13293 if (SWIG_arg_fail(2)) SWIG_fail;
13294 }
13295 }
13296 {
13297 PyThreadState* __tstate = wxPyBeginAllowThreads();
13298 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13299
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 {
13304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13305 }
13306 return resultobj;
13307 fail:
13308 return NULL;
13309 }
13310
13311
13312 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13313 PyObject *obj;
13314 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13315 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13316 Py_INCREF(obj);
13317 return Py_BuildValue((char *)"");
13318 }
13319 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj;
13321 wxString const &arg1_defvalue = wxPyEmptyString ;
13322 wxString *arg1 = (wxString *) &arg1_defvalue ;
13323 wxSound *result;
13324 bool temp1 = false ;
13325 PyObject * obj0 = 0 ;
13326 char *kwnames[] = {
13327 (char *) "fileName", NULL
13328 };
13329
13330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13331 if (obj0) {
13332 {
13333 arg1 = wxString_in_helper(obj0);
13334 if (arg1 == NULL) SWIG_fail;
13335 temp1 = true;
13336 }
13337 }
13338 {
13339 if (!wxPyCheckForApp()) SWIG_fail;
13340 PyThreadState* __tstate = wxPyBeginAllowThreads();
13341 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13342
13343 wxPyEndAllowThreads(__tstate);
13344 if (PyErr_Occurred()) SWIG_fail;
13345 }
13346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13347 {
13348 if (temp1)
13349 delete arg1;
13350 }
13351 return resultobj;
13352 fail:
13353 {
13354 if (temp1)
13355 delete arg1;
13356 }
13357 return NULL;
13358 }
13359
13360
13361 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13362 PyObject *resultobj;
13363 PyObject *arg1 = (PyObject *) 0 ;
13364 wxSound *result;
13365 PyObject * obj0 = 0 ;
13366 char *kwnames[] = {
13367 (char *) "data", NULL
13368 };
13369
13370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13371 arg1 = obj0;
13372 {
13373 if (!wxPyCheckForApp()) SWIG_fail;
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 result = (wxSound *)new_wxSound(arg1);
13376
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj;
13389 wxSound *arg1 = (wxSound *) 0 ;
13390 PyObject * obj0 = 0 ;
13391 char *kwnames[] = {
13392 (char *) "self", NULL
13393 };
13394
13395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13397 if (SWIG_arg_fail(1)) SWIG_fail;
13398 {
13399 PyThreadState* __tstate = wxPyBeginAllowThreads();
13400 delete arg1;
13401
13402 wxPyEndAllowThreads(__tstate);
13403 if (PyErr_Occurred()) SWIG_fail;
13404 }
13405 Py_INCREF(Py_None); resultobj = Py_None;
13406 return resultobj;
13407 fail:
13408 return NULL;
13409 }
13410
13411
13412 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13413 PyObject *resultobj;
13414 wxSound *arg1 = (wxSound *) 0 ;
13415 wxString *arg2 = 0 ;
13416 bool result;
13417 bool temp2 = false ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "self",(char *) "fileName", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13426 if (SWIG_arg_fail(1)) SWIG_fail;
13427 {
13428 arg2 = wxString_in_helper(obj1);
13429 if (arg2 == NULL) SWIG_fail;
13430 temp2 = true;
13431 }
13432 {
13433 PyThreadState* __tstate = wxPyBeginAllowThreads();
13434 result = (bool)(arg1)->Create((wxString const &)*arg2);
13435
13436 wxPyEndAllowThreads(__tstate);
13437 if (PyErr_Occurred()) SWIG_fail;
13438 }
13439 {
13440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13441 }
13442 {
13443 if (temp2)
13444 delete arg2;
13445 }
13446 return resultobj;
13447 fail:
13448 {
13449 if (temp2)
13450 delete arg2;
13451 }
13452 return NULL;
13453 }
13454
13455
13456 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13457 PyObject *resultobj;
13458 wxSound *arg1 = (wxSound *) 0 ;
13459 PyObject *arg2 = (PyObject *) 0 ;
13460 bool result;
13461 PyObject * obj0 = 0 ;
13462 PyObject * obj1 = 0 ;
13463 char *kwnames[] = {
13464 (char *) "self",(char *) "data", NULL
13465 };
13466
13467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13469 if (SWIG_arg_fail(1)) SWIG_fail;
13470 arg2 = obj1;
13471 {
13472 PyThreadState* __tstate = wxPyBeginAllowThreads();
13473 result = (bool)wxSound_CreateFromData(arg1,arg2);
13474
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 {
13479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13480 }
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj;
13489 wxSound *arg1 = (wxSound *) 0 ;
13490 bool result;
13491 PyObject * obj0 = 0 ;
13492 char *kwnames[] = {
13493 (char *) "self", NULL
13494 };
13495
13496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13498 if (SWIG_arg_fail(1)) SWIG_fail;
13499 {
13500 PyThreadState* __tstate = wxPyBeginAllowThreads();
13501 result = (bool)(arg1)->IsOk();
13502
13503 wxPyEndAllowThreads(__tstate);
13504 if (PyErr_Occurred()) SWIG_fail;
13505 }
13506 {
13507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13508 }
13509 return resultobj;
13510 fail:
13511 return NULL;
13512 }
13513
13514
13515 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13516 PyObject *resultobj;
13517 wxSound *arg1 = (wxSound *) 0 ;
13518 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13519 bool result;
13520 PyObject * obj0 = 0 ;
13521 PyObject * obj1 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self",(char *) "flags", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 if (obj1) {
13530 {
13531 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13532 if (SWIG_arg_fail(2)) SWIG_fail;
13533 }
13534 }
13535 {
13536 if (!wxPyCheckForApp()) SWIG_fail;
13537 PyThreadState* __tstate = wxPyBeginAllowThreads();
13538 result = (bool)((wxSound const *)arg1)->Play(arg2);
13539
13540 wxPyEndAllowThreads(__tstate);
13541 if (PyErr_Occurred()) SWIG_fail;
13542 }
13543 {
13544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13545 }
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj;
13554 wxString *arg1 = 0 ;
13555 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13556 bool result;
13557 bool temp1 = false ;
13558 PyObject * obj0 = 0 ;
13559 PyObject * obj1 = 0 ;
13560 char *kwnames[] = {
13561 (char *) "filename",(char *) "flags", NULL
13562 };
13563
13564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13565 {
13566 arg1 = wxString_in_helper(obj0);
13567 if (arg1 == NULL) SWIG_fail;
13568 temp1 = true;
13569 }
13570 if (obj1) {
13571 {
13572 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13573 if (SWIG_arg_fail(2)) SWIG_fail;
13574 }
13575 }
13576 {
13577 if (!wxPyCheckForApp()) SWIG_fail;
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13580
13581 wxPyEndAllowThreads(__tstate);
13582 if (PyErr_Occurred()) SWIG_fail;
13583 }
13584 {
13585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13586 }
13587 {
13588 if (temp1)
13589 delete arg1;
13590 }
13591 return resultobj;
13592 fail:
13593 {
13594 if (temp1)
13595 delete arg1;
13596 }
13597 return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj;
13603 char *kwnames[] = {
13604 NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13608 {
13609 if (!wxPyCheckForApp()) SWIG_fail;
13610 PyThreadState* __tstate = wxPyBeginAllowThreads();
13611 wxSound::Stop();
13612
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 Py_INCREF(Py_None); resultobj = Py_None;
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13624 PyObject *obj;
13625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13626 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13627 Py_INCREF(obj);
13628 return Py_BuildValue((char *)"");
13629 }
13630 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13631 PyObject *resultobj;
13632 wxString *arg1 = 0 ;
13633 wxString *arg2 = 0 ;
13634 wxString *arg3 = 0 ;
13635 wxString *arg4 = 0 ;
13636 wxFileTypeInfo *result;
13637 bool temp1 = false ;
13638 bool temp2 = false ;
13639 bool temp3 = false ;
13640 bool temp4 = false ;
13641 PyObject * obj0 = 0 ;
13642 PyObject * obj1 = 0 ;
13643 PyObject * obj2 = 0 ;
13644 PyObject * obj3 = 0 ;
13645 char *kwnames[] = {
13646 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13647 };
13648
13649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13650 {
13651 arg1 = wxString_in_helper(obj0);
13652 if (arg1 == NULL) SWIG_fail;
13653 temp1 = true;
13654 }
13655 {
13656 arg2 = wxString_in_helper(obj1);
13657 if (arg2 == NULL) SWIG_fail;
13658 temp2 = true;
13659 }
13660 {
13661 arg3 = wxString_in_helper(obj2);
13662 if (arg3 == NULL) SWIG_fail;
13663 temp3 = true;
13664 }
13665 {
13666 arg4 = wxString_in_helper(obj3);
13667 if (arg4 == NULL) SWIG_fail;
13668 temp4 = true;
13669 }
13670 {
13671 PyThreadState* __tstate = wxPyBeginAllowThreads();
13672 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13673
13674 wxPyEndAllowThreads(__tstate);
13675 if (PyErr_Occurred()) SWIG_fail;
13676 }
13677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13678 {
13679 if (temp1)
13680 delete arg1;
13681 }
13682 {
13683 if (temp2)
13684 delete arg2;
13685 }
13686 {
13687 if (temp3)
13688 delete arg3;
13689 }
13690 {
13691 if (temp4)
13692 delete arg4;
13693 }
13694 return resultobj;
13695 fail:
13696 {
13697 if (temp1)
13698 delete arg1;
13699 }
13700 {
13701 if (temp2)
13702 delete arg2;
13703 }
13704 {
13705 if (temp3)
13706 delete arg3;
13707 }
13708 {
13709 if (temp4)
13710 delete arg4;
13711 }
13712 return NULL;
13713 }
13714
13715
13716 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13717 PyObject *resultobj;
13718 wxArrayString *arg1 = 0 ;
13719 wxFileTypeInfo *result;
13720 bool temp1 = false ;
13721 PyObject * obj0 = 0 ;
13722 char *kwnames[] = {
13723 (char *) "sArray", NULL
13724 };
13725
13726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13727 {
13728 if (! PySequence_Check(obj0)) {
13729 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13730 SWIG_fail;
13731 }
13732 arg1 = new wxArrayString;
13733 temp1 = true;
13734 int i, len=PySequence_Length(obj0);
13735 for (i=0; i<len; i++) {
13736 PyObject* item = PySequence_GetItem(obj0, i);
13737 #if wxUSE_UNICODE
13738 PyObject* str = PyObject_Unicode(item);
13739 #else
13740 PyObject* str = PyObject_Str(item);
13741 #endif
13742 if (PyErr_Occurred()) SWIG_fail;
13743 arg1->Add(Py2wxString(str));
13744 Py_DECREF(item);
13745 Py_DECREF(str);
13746 }
13747 }
13748 {
13749 PyThreadState* __tstate = wxPyBeginAllowThreads();
13750 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13751
13752 wxPyEndAllowThreads(__tstate);
13753 if (PyErr_Occurred()) SWIG_fail;
13754 }
13755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13756 {
13757 if (temp1) delete arg1;
13758 }
13759 return resultobj;
13760 fail:
13761 {
13762 if (temp1) delete arg1;
13763 }
13764 return NULL;
13765 }
13766
13767
13768 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13769 PyObject *resultobj;
13770 wxFileTypeInfo *result;
13771 char *kwnames[] = {
13772 NULL
13773 };
13774
13775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13776 {
13777 PyThreadState* __tstate = wxPyBeginAllowThreads();
13778 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13779
13780 wxPyEndAllowThreads(__tstate);
13781 if (PyErr_Occurred()) SWIG_fail;
13782 }
13783 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13784 return resultobj;
13785 fail:
13786 return NULL;
13787 }
13788
13789
13790 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13791 PyObject *resultobj;
13792 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13793 bool result;
13794 PyObject * obj0 = 0 ;
13795 char *kwnames[] = {
13796 (char *) "self", NULL
13797 };
13798
13799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13801 if (SWIG_arg_fail(1)) SWIG_fail;
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13805
13806 wxPyEndAllowThreads(__tstate);
13807 if (PyErr_Occurred()) SWIG_fail;
13808 }
13809 {
13810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13811 }
13812 return resultobj;
13813 fail:
13814 return NULL;
13815 }
13816
13817
13818 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13819 PyObject *resultobj;
13820 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13821 wxString *arg2 = 0 ;
13822 int arg3 = (int) 0 ;
13823 bool temp2 = false ;
13824 PyObject * obj0 = 0 ;
13825 PyObject * obj1 = 0 ;
13826 PyObject * obj2 = 0 ;
13827 char *kwnames[] = {
13828 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13829 };
13830
13831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13833 if (SWIG_arg_fail(1)) SWIG_fail;
13834 {
13835 arg2 = wxString_in_helper(obj1);
13836 if (arg2 == NULL) SWIG_fail;
13837 temp2 = true;
13838 }
13839 if (obj2) {
13840 {
13841 arg3 = (int)(SWIG_As_int(obj2));
13842 if (SWIG_arg_fail(3)) SWIG_fail;
13843 }
13844 }
13845 {
13846 PyThreadState* __tstate = wxPyBeginAllowThreads();
13847 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13848
13849 wxPyEndAllowThreads(__tstate);
13850 if (PyErr_Occurred()) SWIG_fail;
13851 }
13852 Py_INCREF(Py_None); resultobj = Py_None;
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return resultobj;
13858 fail:
13859 {
13860 if (temp2)
13861 delete arg2;
13862 }
13863 return NULL;
13864 }
13865
13866
13867 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj;
13869 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13870 wxString *arg2 = 0 ;
13871 bool temp2 = false ;
13872 PyObject * obj0 = 0 ;
13873 PyObject * obj1 = 0 ;
13874 char *kwnames[] = {
13875 (char *) "self",(char *) "shortDesc", NULL
13876 };
13877
13878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13880 if (SWIG_arg_fail(1)) SWIG_fail;
13881 {
13882 arg2 = wxString_in_helper(obj1);
13883 if (arg2 == NULL) SWIG_fail;
13884 temp2 = true;
13885 }
13886 {
13887 PyThreadState* __tstate = wxPyBeginAllowThreads();
13888 (arg1)->SetShortDesc((wxString const &)*arg2);
13889
13890 wxPyEndAllowThreads(__tstate);
13891 if (PyErr_Occurred()) SWIG_fail;
13892 }
13893 Py_INCREF(Py_None); resultobj = Py_None;
13894 {
13895 if (temp2)
13896 delete arg2;
13897 }
13898 return resultobj;
13899 fail:
13900 {
13901 if (temp2)
13902 delete arg2;
13903 }
13904 return NULL;
13905 }
13906
13907
13908 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13909 PyObject *resultobj;
13910 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13911 wxString *result;
13912 PyObject * obj0 = 0 ;
13913 char *kwnames[] = {
13914 (char *) "self", NULL
13915 };
13916
13917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13919 if (SWIG_arg_fail(1)) SWIG_fail;
13920 {
13921 PyThreadState* __tstate = wxPyBeginAllowThreads();
13922 {
13923 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13924 result = (wxString *) &_result_ref;
13925 }
13926
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 {
13931 #if wxUSE_UNICODE
13932 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13933 #else
13934 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13935 #endif
13936 }
13937 return resultobj;
13938 fail:
13939 return NULL;
13940 }
13941
13942
13943 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13944 PyObject *resultobj;
13945 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13946 wxString *result;
13947 PyObject * obj0 = 0 ;
13948 char *kwnames[] = {
13949 (char *) "self", NULL
13950 };
13951
13952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13954 if (SWIG_arg_fail(1)) SWIG_fail;
13955 {
13956 PyThreadState* __tstate = wxPyBeginAllowThreads();
13957 {
13958 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13959 result = (wxString *) &_result_ref;
13960 }
13961
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 {
13966 #if wxUSE_UNICODE
13967 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13968 #else
13969 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13970 #endif
13971 }
13972 return resultobj;
13973 fail:
13974 return NULL;
13975 }
13976
13977
13978 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13979 PyObject *resultobj;
13980 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13981 wxString *result;
13982 PyObject * obj0 = 0 ;
13983 char *kwnames[] = {
13984 (char *) "self", NULL
13985 };
13986
13987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13989 if (SWIG_arg_fail(1)) SWIG_fail;
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 {
13993 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
13994 result = (wxString *) &_result_ref;
13995 }
13996
13997 wxPyEndAllowThreads(__tstate);
13998 if (PyErr_Occurred()) SWIG_fail;
13999 }
14000 {
14001 #if wxUSE_UNICODE
14002 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14003 #else
14004 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14005 #endif
14006 }
14007 return resultobj;
14008 fail:
14009 return NULL;
14010 }
14011
14012
14013 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14014 PyObject *resultobj;
14015 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14016 wxString *result;
14017 PyObject * obj0 = 0 ;
14018 char *kwnames[] = {
14019 (char *) "self", NULL
14020 };
14021
14022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14024 if (SWIG_arg_fail(1)) SWIG_fail;
14025 {
14026 PyThreadState* __tstate = wxPyBeginAllowThreads();
14027 {
14028 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14029 result = (wxString *) &_result_ref;
14030 }
14031
14032 wxPyEndAllowThreads(__tstate);
14033 if (PyErr_Occurred()) SWIG_fail;
14034 }
14035 {
14036 #if wxUSE_UNICODE
14037 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14038 #else
14039 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14040 #endif
14041 }
14042 return resultobj;
14043 fail:
14044 return NULL;
14045 }
14046
14047
14048 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14049 PyObject *resultobj;
14050 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14051 wxString *result;
14052 PyObject * obj0 = 0 ;
14053 char *kwnames[] = {
14054 (char *) "self", NULL
14055 };
14056
14057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14059 if (SWIG_arg_fail(1)) SWIG_fail;
14060 {
14061 PyThreadState* __tstate = wxPyBeginAllowThreads();
14062 {
14063 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14064 result = (wxString *) &_result_ref;
14065 }
14066
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 {
14071 #if wxUSE_UNICODE
14072 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14073 #else
14074 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14075 #endif
14076 }
14077 return resultobj;
14078 fail:
14079 return NULL;
14080 }
14081
14082
14083 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14084 PyObject *resultobj;
14085 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14086 wxArrayString *result;
14087 PyObject * obj0 = 0 ;
14088 char *kwnames[] = {
14089 (char *) "self", NULL
14090 };
14091
14092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14094 if (SWIG_arg_fail(1)) SWIG_fail;
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 {
14098 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14099 result = (wxArrayString *) &_result_ref;
14100 }
14101
14102 wxPyEndAllowThreads(__tstate);
14103 if (PyErr_Occurred()) SWIG_fail;
14104 }
14105 {
14106 resultobj = wxArrayString2PyList_helper(*result);
14107 }
14108 return resultobj;
14109 fail:
14110 return NULL;
14111 }
14112
14113
14114 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14115 PyObject *resultobj;
14116 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14117 int result;
14118 PyObject * obj0 = 0 ;
14119 char *kwnames[] = {
14120 (char *) "self", NULL
14121 };
14122
14123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14125 if (SWIG_arg_fail(1)) SWIG_fail;
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = SWIG_From_int((int)(result));
14135 }
14136 return resultobj;
14137 fail:
14138 return NULL;
14139 }
14140
14141
14142 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14143 PyObject *resultobj;
14144 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14145 wxString *result;
14146 PyObject * obj0 = 0 ;
14147 char *kwnames[] = {
14148 (char *) "self", NULL
14149 };
14150
14151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14153 if (SWIG_arg_fail(1)) SWIG_fail;
14154 {
14155 PyThreadState* __tstate = wxPyBeginAllowThreads();
14156 {
14157 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14158 result = (wxString *) &_result_ref;
14159 }
14160
14161 wxPyEndAllowThreads(__tstate);
14162 if (PyErr_Occurred()) SWIG_fail;
14163 }
14164 {
14165 #if wxUSE_UNICODE
14166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14167 #else
14168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14169 #endif
14170 }
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14180 int result;
14181 PyObject * obj0 = 0 ;
14182 char *kwnames[] = {
14183 (char *) "self", NULL
14184 };
14185
14186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14188 if (SWIG_arg_fail(1)) SWIG_fail;
14189 {
14190 PyThreadState* __tstate = wxPyBeginAllowThreads();
14191 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14192
14193 wxPyEndAllowThreads(__tstate);
14194 if (PyErr_Occurred()) SWIG_fail;
14195 }
14196 {
14197 resultobj = SWIG_From_int((int)(result));
14198 }
14199 return resultobj;
14200 fail:
14201 return NULL;
14202 }
14203
14204
14205 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14206 PyObject *obj;
14207 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14208 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14209 Py_INCREF(obj);
14210 return Py_BuildValue((char *)"");
14211 }
14212 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14213 PyObject *resultobj;
14214 wxFileTypeInfo *arg1 = 0 ;
14215 wxFileType *result;
14216 PyObject * obj0 = 0 ;
14217 char *kwnames[] = {
14218 (char *) "ftInfo", NULL
14219 };
14220
14221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14222 {
14223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14224 if (SWIG_arg_fail(1)) SWIG_fail;
14225 if (arg1 == NULL) {
14226 SWIG_null_ref("wxFileTypeInfo");
14227 }
14228 if (SWIG_arg_fail(1)) SWIG_fail;
14229 }
14230 {
14231 PyThreadState* __tstate = wxPyBeginAllowThreads();
14232 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14233
14234 wxPyEndAllowThreads(__tstate);
14235 if (PyErr_Occurred()) SWIG_fail;
14236 }
14237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14245 PyObject *resultobj;
14246 wxFileType *arg1 = (wxFileType *) 0 ;
14247 PyObject * obj0 = 0 ;
14248 char *kwnames[] = {
14249 (char *) "self", NULL
14250 };
14251
14252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14254 if (SWIG_arg_fail(1)) SWIG_fail;
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 delete arg1;
14258
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 Py_INCREF(Py_None); resultobj = Py_None;
14263 return resultobj;
14264 fail:
14265 return NULL;
14266 }
14267
14268
14269 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14270 PyObject *resultobj;
14271 wxFileType *arg1 = (wxFileType *) 0 ;
14272 PyObject *result;
14273 PyObject * obj0 = 0 ;
14274 char *kwnames[] = {
14275 (char *) "self", NULL
14276 };
14277
14278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14280 if (SWIG_arg_fail(1)) SWIG_fail;
14281 {
14282 PyThreadState* __tstate = wxPyBeginAllowThreads();
14283 result = (PyObject *)wxFileType_GetMimeType(arg1);
14284
14285 wxPyEndAllowThreads(__tstate);
14286 if (PyErr_Occurred()) SWIG_fail;
14287 }
14288 resultobj = result;
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj;
14297 wxFileType *arg1 = (wxFileType *) 0 ;
14298 PyObject *result;
14299 PyObject * obj0 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "self", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14306 if (SWIG_arg_fail(1)) SWIG_fail;
14307 {
14308 PyThreadState* __tstate = wxPyBeginAllowThreads();
14309 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14310
14311 wxPyEndAllowThreads(__tstate);
14312 if (PyErr_Occurred()) SWIG_fail;
14313 }
14314 resultobj = result;
14315 return resultobj;
14316 fail:
14317 return NULL;
14318 }
14319
14320
14321 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14322 PyObject *resultobj;
14323 wxFileType *arg1 = (wxFileType *) 0 ;
14324 PyObject *result;
14325 PyObject * obj0 = 0 ;
14326 char *kwnames[] = {
14327 (char *) "self", NULL
14328 };
14329
14330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14332 if (SWIG_arg_fail(1)) SWIG_fail;
14333 {
14334 PyThreadState* __tstate = wxPyBeginAllowThreads();
14335 result = (PyObject *)wxFileType_GetExtensions(arg1);
14336
14337 wxPyEndAllowThreads(__tstate);
14338 if (PyErr_Occurred()) SWIG_fail;
14339 }
14340 resultobj = result;
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14348 PyObject *resultobj;
14349 wxFileType *arg1 = (wxFileType *) 0 ;
14350 wxIcon *result;
14351 PyObject * obj0 = 0 ;
14352 char *kwnames[] = {
14353 (char *) "self", NULL
14354 };
14355
14356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14358 if (SWIG_arg_fail(1)) SWIG_fail;
14359 {
14360 PyThreadState* __tstate = wxPyBeginAllowThreads();
14361 result = (wxIcon *)wxFileType_GetIcon(arg1);
14362
14363 wxPyEndAllowThreads(__tstate);
14364 if (PyErr_Occurred()) SWIG_fail;
14365 }
14366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14367 return resultobj;
14368 fail:
14369 return NULL;
14370 }
14371
14372
14373 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14374 PyObject *resultobj;
14375 wxFileType *arg1 = (wxFileType *) 0 ;
14376 PyObject *result;
14377 PyObject * obj0 = 0 ;
14378 char *kwnames[] = {
14379 (char *) "self", NULL
14380 };
14381
14382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14384 if (SWIG_arg_fail(1)) SWIG_fail;
14385 {
14386 PyThreadState* __tstate = wxPyBeginAllowThreads();
14387 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14388
14389 wxPyEndAllowThreads(__tstate);
14390 if (PyErr_Occurred()) SWIG_fail;
14391 }
14392 resultobj = result;
14393 return resultobj;
14394 fail:
14395 return NULL;
14396 }
14397
14398
14399 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14400 PyObject *resultobj;
14401 wxFileType *arg1 = (wxFileType *) 0 ;
14402 PyObject *result;
14403 PyObject * obj0 = 0 ;
14404 char *kwnames[] = {
14405 (char *) "self", NULL
14406 };
14407
14408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14410 if (SWIG_arg_fail(1)) SWIG_fail;
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (PyObject *)wxFileType_GetDescription(arg1);
14414
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 resultobj = result;
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14426 PyObject *resultobj;
14427 wxFileType *arg1 = (wxFileType *) 0 ;
14428 wxString *arg2 = 0 ;
14429 wxString const &arg3_defvalue = wxPyEmptyString ;
14430 wxString *arg3 = (wxString *) &arg3_defvalue ;
14431 PyObject *result;
14432 bool temp2 = false ;
14433 bool temp3 = false ;
14434 PyObject * obj0 = 0 ;
14435 PyObject * obj1 = 0 ;
14436 PyObject * obj2 = 0 ;
14437 char *kwnames[] = {
14438 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14439 };
14440
14441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14443 if (SWIG_arg_fail(1)) SWIG_fail;
14444 {
14445 arg2 = wxString_in_helper(obj1);
14446 if (arg2 == NULL) SWIG_fail;
14447 temp2 = true;
14448 }
14449 if (obj2) {
14450 {
14451 arg3 = wxString_in_helper(obj2);
14452 if (arg3 == NULL) SWIG_fail;
14453 temp3 = true;
14454 }
14455 }
14456 {
14457 PyThreadState* __tstate = wxPyBeginAllowThreads();
14458 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14459
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 resultobj = result;
14464 {
14465 if (temp2)
14466 delete arg2;
14467 }
14468 {
14469 if (temp3)
14470 delete arg3;
14471 }
14472 return resultobj;
14473 fail:
14474 {
14475 if (temp2)
14476 delete arg2;
14477 }
14478 {
14479 if (temp3)
14480 delete arg3;
14481 }
14482 return NULL;
14483 }
14484
14485
14486 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14487 PyObject *resultobj;
14488 wxFileType *arg1 = (wxFileType *) 0 ;
14489 wxString *arg2 = 0 ;
14490 wxString const &arg3_defvalue = wxPyEmptyString ;
14491 wxString *arg3 = (wxString *) &arg3_defvalue ;
14492 PyObject *result;
14493 bool temp2 = false ;
14494 bool temp3 = false ;
14495 PyObject * obj0 = 0 ;
14496 PyObject * obj1 = 0 ;
14497 PyObject * obj2 = 0 ;
14498 char *kwnames[] = {
14499 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14500 };
14501
14502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14504 if (SWIG_arg_fail(1)) SWIG_fail;
14505 {
14506 arg2 = wxString_in_helper(obj1);
14507 if (arg2 == NULL) SWIG_fail;
14508 temp2 = true;
14509 }
14510 if (obj2) {
14511 {
14512 arg3 = wxString_in_helper(obj2);
14513 if (arg3 == NULL) SWIG_fail;
14514 temp3 = true;
14515 }
14516 }
14517 {
14518 PyThreadState* __tstate = wxPyBeginAllowThreads();
14519 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14520
14521 wxPyEndAllowThreads(__tstate);
14522 if (PyErr_Occurred()) SWIG_fail;
14523 }
14524 resultobj = result;
14525 {
14526 if (temp2)
14527 delete arg2;
14528 }
14529 {
14530 if (temp3)
14531 delete arg3;
14532 }
14533 return resultobj;
14534 fail:
14535 {
14536 if (temp2)
14537 delete arg2;
14538 }
14539 {
14540 if (temp3)
14541 delete arg3;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj;
14549 wxFileType *arg1 = (wxFileType *) 0 ;
14550 wxString *arg2 = 0 ;
14551 wxString const &arg3_defvalue = wxPyEmptyString ;
14552 wxString *arg3 = (wxString *) &arg3_defvalue ;
14553 PyObject *result;
14554 bool temp2 = false ;
14555 bool temp3 = false ;
14556 PyObject * obj0 = 0 ;
14557 PyObject * obj1 = 0 ;
14558 PyObject * obj2 = 0 ;
14559 char *kwnames[] = {
14560 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14561 };
14562
14563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14565 if (SWIG_arg_fail(1)) SWIG_fail;
14566 {
14567 arg2 = wxString_in_helper(obj1);
14568 if (arg2 == NULL) SWIG_fail;
14569 temp2 = true;
14570 }
14571 if (obj2) {
14572 {
14573 arg3 = wxString_in_helper(obj2);
14574 if (arg3 == NULL) SWIG_fail;
14575 temp3 = true;
14576 }
14577 }
14578 {
14579 PyThreadState* __tstate = wxPyBeginAllowThreads();
14580 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14581
14582 wxPyEndAllowThreads(__tstate);
14583 if (PyErr_Occurred()) SWIG_fail;
14584 }
14585 resultobj = result;
14586 {
14587 if (temp2)
14588 delete arg2;
14589 }
14590 {
14591 if (temp3)
14592 delete arg3;
14593 }
14594 return resultobj;
14595 fail:
14596 {
14597 if (temp2)
14598 delete arg2;
14599 }
14600 {
14601 if (temp3)
14602 delete arg3;
14603 }
14604 return NULL;
14605 }
14606
14607
14608 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14609 PyObject *resultobj;
14610 wxFileType *arg1 = (wxFileType *) 0 ;
14611 wxString *arg2 = 0 ;
14612 wxString *arg3 = 0 ;
14613 bool arg4 = (bool) true ;
14614 bool result;
14615 bool temp2 = false ;
14616 bool temp3 = false ;
14617 PyObject * obj0 = 0 ;
14618 PyObject * obj1 = 0 ;
14619 PyObject * obj2 = 0 ;
14620 PyObject * obj3 = 0 ;
14621 char *kwnames[] = {
14622 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14623 };
14624
14625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14627 if (SWIG_arg_fail(1)) SWIG_fail;
14628 {
14629 arg2 = wxString_in_helper(obj1);
14630 if (arg2 == NULL) SWIG_fail;
14631 temp2 = true;
14632 }
14633 {
14634 arg3 = wxString_in_helper(obj2);
14635 if (arg3 == NULL) SWIG_fail;
14636 temp3 = true;
14637 }
14638 if (obj3) {
14639 {
14640 arg4 = (bool)(SWIG_As_bool(obj3));
14641 if (SWIG_arg_fail(4)) SWIG_fail;
14642 }
14643 }
14644 {
14645 PyThreadState* __tstate = wxPyBeginAllowThreads();
14646 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14647
14648 wxPyEndAllowThreads(__tstate);
14649 if (PyErr_Occurred()) SWIG_fail;
14650 }
14651 {
14652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14653 }
14654 {
14655 if (temp2)
14656 delete arg2;
14657 }
14658 {
14659 if (temp3)
14660 delete arg3;
14661 }
14662 return resultobj;
14663 fail:
14664 {
14665 if (temp2)
14666 delete arg2;
14667 }
14668 {
14669 if (temp3)
14670 delete arg3;
14671 }
14672 return NULL;
14673 }
14674
14675
14676 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14677 PyObject *resultobj;
14678 wxFileType *arg1 = (wxFileType *) 0 ;
14679 wxString const &arg2_defvalue = wxPyEmptyString ;
14680 wxString *arg2 = (wxString *) &arg2_defvalue ;
14681 int arg3 = (int) 0 ;
14682 bool result;
14683 bool temp2 = false ;
14684 PyObject * obj0 = 0 ;
14685 PyObject * obj1 = 0 ;
14686 PyObject * obj2 = 0 ;
14687 char *kwnames[] = {
14688 (char *) "self",(char *) "cmd",(char *) "index", NULL
14689 };
14690
14691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14693 if (SWIG_arg_fail(1)) SWIG_fail;
14694 if (obj1) {
14695 {
14696 arg2 = wxString_in_helper(obj1);
14697 if (arg2 == NULL) SWIG_fail;
14698 temp2 = true;
14699 }
14700 }
14701 if (obj2) {
14702 {
14703 arg3 = (int)(SWIG_As_int(obj2));
14704 if (SWIG_arg_fail(3)) SWIG_fail;
14705 }
14706 }
14707 {
14708 PyThreadState* __tstate = wxPyBeginAllowThreads();
14709 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14710
14711 wxPyEndAllowThreads(__tstate);
14712 if (PyErr_Occurred()) SWIG_fail;
14713 }
14714 {
14715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14716 }
14717 {
14718 if (temp2)
14719 delete arg2;
14720 }
14721 return resultobj;
14722 fail:
14723 {
14724 if (temp2)
14725 delete arg2;
14726 }
14727 return NULL;
14728 }
14729
14730
14731 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14732 PyObject *resultobj;
14733 wxFileType *arg1 = (wxFileType *) 0 ;
14734 bool result;
14735 PyObject * obj0 = 0 ;
14736 char *kwnames[] = {
14737 (char *) "self", NULL
14738 };
14739
14740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14742 if (SWIG_arg_fail(1)) SWIG_fail;
14743 {
14744 PyThreadState* __tstate = wxPyBeginAllowThreads();
14745 result = (bool)(arg1)->Unassociate();
14746
14747 wxPyEndAllowThreads(__tstate);
14748 if (PyErr_Occurred()) SWIG_fail;
14749 }
14750 {
14751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14752 }
14753 return resultobj;
14754 fail:
14755 return NULL;
14756 }
14757
14758
14759 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14760 PyObject *resultobj;
14761 wxString *arg1 = 0 ;
14762 wxString *arg2 = 0 ;
14763 wxString const &arg3_defvalue = wxPyEmptyString ;
14764 wxString *arg3 = (wxString *) &arg3_defvalue ;
14765 wxString result;
14766 bool temp1 = false ;
14767 bool temp2 = false ;
14768 bool temp3 = false ;
14769 PyObject * obj0 = 0 ;
14770 PyObject * obj1 = 0 ;
14771 PyObject * obj2 = 0 ;
14772 char *kwnames[] = {
14773 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14774 };
14775
14776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14777 {
14778 arg1 = wxString_in_helper(obj0);
14779 if (arg1 == NULL) SWIG_fail;
14780 temp1 = true;
14781 }
14782 {
14783 arg2 = wxString_in_helper(obj1);
14784 if (arg2 == NULL) SWIG_fail;
14785 temp2 = true;
14786 }
14787 if (obj2) {
14788 {
14789 arg3 = wxString_in_helper(obj2);
14790 if (arg3 == NULL) SWIG_fail;
14791 temp3 = true;
14792 }
14793 }
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14797
14798 wxPyEndAllowThreads(__tstate);
14799 if (PyErr_Occurred()) SWIG_fail;
14800 }
14801 {
14802 #if wxUSE_UNICODE
14803 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14804 #else
14805 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14806 #endif
14807 }
14808 {
14809 if (temp1)
14810 delete arg1;
14811 }
14812 {
14813 if (temp2)
14814 delete arg2;
14815 }
14816 {
14817 if (temp3)
14818 delete arg3;
14819 }
14820 return resultobj;
14821 fail:
14822 {
14823 if (temp1)
14824 delete arg1;
14825 }
14826 {
14827 if (temp2)
14828 delete arg2;
14829 }
14830 {
14831 if (temp3)
14832 delete arg3;
14833 }
14834 return NULL;
14835 }
14836
14837
14838 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14839 PyObject *obj;
14840 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14841 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14842 Py_INCREF(obj);
14843 return Py_BuildValue((char *)"");
14844 }
14845 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14846 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14847 return 1;
14848 }
14849
14850
14851 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14852 PyObject *pyobj;
14853
14854 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14855 return pyobj;
14856 }
14857
14858
14859 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14860 PyObject *resultobj;
14861 wxString *arg1 = 0 ;
14862 wxString *arg2 = 0 ;
14863 bool result;
14864 bool temp1 = false ;
14865 bool temp2 = false ;
14866 PyObject * obj0 = 0 ;
14867 PyObject * obj1 = 0 ;
14868 char *kwnames[] = {
14869 (char *) "mimeType",(char *) "wildcard", NULL
14870 };
14871
14872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14873 {
14874 arg1 = wxString_in_helper(obj0);
14875 if (arg1 == NULL) SWIG_fail;
14876 temp1 = true;
14877 }
14878 {
14879 arg2 = wxString_in_helper(obj1);
14880 if (arg2 == NULL) SWIG_fail;
14881 temp2 = true;
14882 }
14883 {
14884 PyThreadState* __tstate = wxPyBeginAllowThreads();
14885 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14886
14887 wxPyEndAllowThreads(__tstate);
14888 if (PyErr_Occurred()) SWIG_fail;
14889 }
14890 {
14891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14892 }
14893 {
14894 if (temp1)
14895 delete arg1;
14896 }
14897 {
14898 if (temp2)
14899 delete arg2;
14900 }
14901 return resultobj;
14902 fail:
14903 {
14904 if (temp1)
14905 delete arg1;
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 return NULL;
14912 }
14913
14914
14915 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14916 PyObject *resultobj;
14917 wxMimeTypesManager *result;
14918 char *kwnames[] = {
14919 NULL
14920 };
14921
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj;
14939 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14940 int arg2 = (int) wxMAILCAP_ALL ;
14941 wxString const &arg3_defvalue = wxPyEmptyString ;
14942 wxString *arg3 = (wxString *) &arg3_defvalue ;
14943 bool temp3 = false ;
14944 PyObject * obj0 = 0 ;
14945 PyObject * obj1 = 0 ;
14946 PyObject * obj2 = 0 ;
14947 char *kwnames[] = {
14948 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14949 };
14950
14951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14953 if (SWIG_arg_fail(1)) SWIG_fail;
14954 if (obj1) {
14955 {
14956 arg2 = (int)(SWIG_As_int(obj1));
14957 if (SWIG_arg_fail(2)) SWIG_fail;
14958 }
14959 }
14960 if (obj2) {
14961 {
14962 arg3 = wxString_in_helper(obj2);
14963 if (arg3 == NULL) SWIG_fail;
14964 temp3 = true;
14965 }
14966 }
14967 {
14968 PyThreadState* __tstate = wxPyBeginAllowThreads();
14969 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14970
14971 wxPyEndAllowThreads(__tstate);
14972 if (PyErr_Occurred()) SWIG_fail;
14973 }
14974 Py_INCREF(Py_None); resultobj = Py_None;
14975 {
14976 if (temp3)
14977 delete arg3;
14978 }
14979 return resultobj;
14980 fail:
14981 {
14982 if (temp3)
14983 delete arg3;
14984 }
14985 return NULL;
14986 }
14987
14988
14989 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj;
14991 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14992 PyObject * obj0 = 0 ;
14993 char *kwnames[] = {
14994 (char *) "self", NULL
14995 };
14996
14997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
14998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14999 if (SWIG_arg_fail(1)) SWIG_fail;
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 (arg1)->ClearData();
15003
15004 wxPyEndAllowThreads(__tstate);
15005 if (PyErr_Occurred()) SWIG_fail;
15006 }
15007 Py_INCREF(Py_None); resultobj = Py_None;
15008 return resultobj;
15009 fail:
15010 return NULL;
15011 }
15012
15013
15014 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15015 PyObject *resultobj;
15016 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15017 wxString *arg2 = 0 ;
15018 wxFileType *result;
15019 bool temp2 = false ;
15020 PyObject * obj0 = 0 ;
15021 PyObject * obj1 = 0 ;
15022 char *kwnames[] = {
15023 (char *) "self",(char *) "ext", NULL
15024 };
15025
15026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15028 if (SWIG_arg_fail(1)) SWIG_fail;
15029 {
15030 arg2 = wxString_in_helper(obj1);
15031 if (arg2 == NULL) SWIG_fail;
15032 temp2 = true;
15033 }
15034 {
15035 PyThreadState* __tstate = wxPyBeginAllowThreads();
15036 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15037
15038 wxPyEndAllowThreads(__tstate);
15039 if (PyErr_Occurred()) SWIG_fail;
15040 }
15041 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15042 {
15043 if (temp2)
15044 delete arg2;
15045 }
15046 return resultobj;
15047 fail:
15048 {
15049 if (temp2)
15050 delete arg2;
15051 }
15052 return NULL;
15053 }
15054
15055
15056 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15057 PyObject *resultobj;
15058 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15059 wxString *arg2 = 0 ;
15060 wxFileType *result;
15061 bool temp2 = false ;
15062 PyObject * obj0 = 0 ;
15063 PyObject * obj1 = 0 ;
15064 char *kwnames[] = {
15065 (char *) "self",(char *) "mimeType", NULL
15066 };
15067
15068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15070 if (SWIG_arg_fail(1)) SWIG_fail;
15071 {
15072 arg2 = wxString_in_helper(obj1);
15073 if (arg2 == NULL) SWIG_fail;
15074 temp2 = true;
15075 }
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15079
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15084 {
15085 if (temp2)
15086 delete arg2;
15087 }
15088 return resultobj;
15089 fail:
15090 {
15091 if (temp2)
15092 delete arg2;
15093 }
15094 return NULL;
15095 }
15096
15097
15098 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15099 PyObject *resultobj;
15100 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15101 wxString *arg2 = 0 ;
15102 bool arg3 = (bool) false ;
15103 bool result;
15104 bool temp2 = false ;
15105 PyObject * obj0 = 0 ;
15106 PyObject * obj1 = 0 ;
15107 PyObject * obj2 = 0 ;
15108 char *kwnames[] = {
15109 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15110 };
15111
15112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15114 if (SWIG_arg_fail(1)) SWIG_fail;
15115 {
15116 arg2 = wxString_in_helper(obj1);
15117 if (arg2 == NULL) SWIG_fail;
15118 temp2 = true;
15119 }
15120 if (obj2) {
15121 {
15122 arg3 = (bool)(SWIG_As_bool(obj2));
15123 if (SWIG_arg_fail(3)) SWIG_fail;
15124 }
15125 }
15126 {
15127 PyThreadState* __tstate = wxPyBeginAllowThreads();
15128 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15129
15130 wxPyEndAllowThreads(__tstate);
15131 if (PyErr_Occurred()) SWIG_fail;
15132 }
15133 {
15134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15135 }
15136 {
15137 if (temp2)
15138 delete arg2;
15139 }
15140 return resultobj;
15141 fail:
15142 {
15143 if (temp2)
15144 delete arg2;
15145 }
15146 return NULL;
15147 }
15148
15149
15150 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15151 PyObject *resultobj;
15152 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15153 wxString *arg2 = 0 ;
15154 bool result;
15155 bool temp2 = false ;
15156 PyObject * obj0 = 0 ;
15157 PyObject * obj1 = 0 ;
15158 char *kwnames[] = {
15159 (char *) "self",(char *) "filename", NULL
15160 };
15161
15162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15164 if (SWIG_arg_fail(1)) SWIG_fail;
15165 {
15166 arg2 = wxString_in_helper(obj1);
15167 if (arg2 == NULL) SWIG_fail;
15168 temp2 = true;
15169 }
15170 {
15171 PyThreadState* __tstate = wxPyBeginAllowThreads();
15172 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15173
15174 wxPyEndAllowThreads(__tstate);
15175 if (PyErr_Occurred()) SWIG_fail;
15176 }
15177 {
15178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15179 }
15180 {
15181 if (temp2)
15182 delete arg2;
15183 }
15184 return resultobj;
15185 fail:
15186 {
15187 if (temp2)
15188 delete arg2;
15189 }
15190 return NULL;
15191 }
15192
15193
15194 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15195 PyObject *resultobj;
15196 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15197 PyObject *result;
15198 PyObject * obj0 = 0 ;
15199 char *kwnames[] = {
15200 (char *) "self", NULL
15201 };
15202
15203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15205 if (SWIG_arg_fail(1)) SWIG_fail;
15206 {
15207 PyThreadState* __tstate = wxPyBeginAllowThreads();
15208 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15209
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 resultobj = result;
15214 return resultobj;
15215 fail:
15216 return NULL;
15217 }
15218
15219
15220 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15221 PyObject *resultobj;
15222 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15223 wxFileTypeInfo *arg2 = 0 ;
15224 PyObject * obj0 = 0 ;
15225 PyObject * obj1 = 0 ;
15226 char *kwnames[] = {
15227 (char *) "self",(char *) "ft", NULL
15228 };
15229
15230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15232 if (SWIG_arg_fail(1)) SWIG_fail;
15233 {
15234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15235 if (SWIG_arg_fail(2)) SWIG_fail;
15236 if (arg2 == NULL) {
15237 SWIG_null_ref("wxFileTypeInfo");
15238 }
15239 if (SWIG_arg_fail(2)) SWIG_fail;
15240 }
15241 {
15242 PyThreadState* __tstate = wxPyBeginAllowThreads();
15243 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15244
15245 wxPyEndAllowThreads(__tstate);
15246 if (PyErr_Occurred()) SWIG_fail;
15247 }
15248 Py_INCREF(Py_None); resultobj = Py_None;
15249 return resultobj;
15250 fail:
15251 return NULL;
15252 }
15253
15254
15255 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15256 PyObject *resultobj;
15257 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15258 wxFileTypeInfo *arg2 = 0 ;
15259 wxFileType *result;
15260 PyObject * obj0 = 0 ;
15261 PyObject * obj1 = 0 ;
15262 char *kwnames[] = {
15263 (char *) "self",(char *) "ftInfo", NULL
15264 };
15265
15266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15268 if (SWIG_arg_fail(1)) SWIG_fail;
15269 {
15270 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15271 if (SWIG_arg_fail(2)) SWIG_fail;
15272 if (arg2 == NULL) {
15273 SWIG_null_ref("wxFileTypeInfo");
15274 }
15275 if (SWIG_arg_fail(2)) SWIG_fail;
15276 }
15277 {
15278 PyThreadState* __tstate = wxPyBeginAllowThreads();
15279 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15280
15281 wxPyEndAllowThreads(__tstate);
15282 if (PyErr_Occurred()) SWIG_fail;
15283 }
15284 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15285 return resultobj;
15286 fail:
15287 return NULL;
15288 }
15289
15290
15291 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15292 PyObject *resultobj;
15293 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15294 wxFileType *arg2 = (wxFileType *) 0 ;
15295 bool result;
15296 PyObject * obj0 = 0 ;
15297 PyObject * obj1 = 0 ;
15298 char *kwnames[] = {
15299 (char *) "self",(char *) "ft", NULL
15300 };
15301
15302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15304 if (SWIG_arg_fail(1)) SWIG_fail;
15305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15306 if (SWIG_arg_fail(2)) SWIG_fail;
15307 {
15308 PyThreadState* __tstate = wxPyBeginAllowThreads();
15309 result = (bool)(arg1)->Unassociate(arg2);
15310
15311 wxPyEndAllowThreads(__tstate);
15312 if (PyErr_Occurred()) SWIG_fail;
15313 }
15314 {
15315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15316 }
15317 return resultobj;
15318 fail:
15319 return NULL;
15320 }
15321
15322
15323 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj;
15325 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15326 PyObject * obj0 = 0 ;
15327 char *kwnames[] = {
15328 (char *) "self", NULL
15329 };
15330
15331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15333 if (SWIG_arg_fail(1)) SWIG_fail;
15334 {
15335 PyThreadState* __tstate = wxPyBeginAllowThreads();
15336 delete arg1;
15337
15338 wxPyEndAllowThreads(__tstate);
15339 if (PyErr_Occurred()) SWIG_fail;
15340 }
15341 Py_INCREF(Py_None); resultobj = Py_None;
15342 return resultobj;
15343 fail:
15344 return NULL;
15345 }
15346
15347
15348 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15349 PyObject *obj;
15350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15351 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15352 Py_INCREF(obj);
15353 return Py_BuildValue((char *)"");
15354 }
15355 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15356 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15357 return 1;
15358 }
15359
15360
15361 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15362 PyObject *pyobj;
15363
15364 {
15365 #if wxUSE_UNICODE
15366 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15367 #else
15368 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15369 #endif
15370 }
15371 return pyobj;
15372 }
15373
15374
15375 static int _wrap_ART_MENU_set(PyObject *) {
15376 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15377 return 1;
15378 }
15379
15380
15381 static PyObject *_wrap_ART_MENU_get(void) {
15382 PyObject *pyobj;
15383
15384 {
15385 #if wxUSE_UNICODE
15386 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15387 #else
15388 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15389 #endif
15390 }
15391 return pyobj;
15392 }
15393
15394
15395 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15396 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15397 return 1;
15398 }
15399
15400
15401 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15402 PyObject *pyobj;
15403
15404 {
15405 #if wxUSE_UNICODE
15406 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15407 #else
15408 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15409 #endif
15410 }
15411 return pyobj;
15412 }
15413
15414
15415 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15416 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15417 return 1;
15418 }
15419
15420
15421 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15422 PyObject *pyobj;
15423
15424 {
15425 #if wxUSE_UNICODE
15426 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15427 #else
15428 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15429 #endif
15430 }
15431 return pyobj;
15432 }
15433
15434
15435 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15436 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15437 return 1;
15438 }
15439
15440
15441 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15442 PyObject *pyobj;
15443
15444 {
15445 #if wxUSE_UNICODE
15446 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15447 #else
15448 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15449 #endif
15450 }
15451 return pyobj;
15452 }
15453
15454
15455 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15456 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15457 return 1;
15458 }
15459
15460
15461 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15462 PyObject *pyobj;
15463
15464 {
15465 #if wxUSE_UNICODE
15466 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15467 #else
15468 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15469 #endif
15470 }
15471 return pyobj;
15472 }
15473
15474
15475 static int _wrap_ART_BUTTON_set(PyObject *) {
15476 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15477 return 1;
15478 }
15479
15480
15481 static PyObject *_wrap_ART_BUTTON_get(void) {
15482 PyObject *pyobj;
15483
15484 {
15485 #if wxUSE_UNICODE
15486 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15487 #else
15488 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15489 #endif
15490 }
15491 return pyobj;
15492 }
15493
15494
15495 static int _wrap_ART_OTHER_set(PyObject *) {
15496 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15497 return 1;
15498 }
15499
15500
15501 static PyObject *_wrap_ART_OTHER_get(void) {
15502 PyObject *pyobj;
15503
15504 {
15505 #if wxUSE_UNICODE
15506 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15507 #else
15508 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15509 #endif
15510 }
15511 return pyobj;
15512 }
15513
15514
15515 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15516 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15517 return 1;
15518 }
15519
15520
15521 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15522 PyObject *pyobj;
15523
15524 {
15525 #if wxUSE_UNICODE
15526 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15527 #else
15528 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15529 #endif
15530 }
15531 return pyobj;
15532 }
15533
15534
15535 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15536 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15537 return 1;
15538 }
15539
15540
15541 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15542 PyObject *pyobj;
15543
15544 {
15545 #if wxUSE_UNICODE
15546 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15547 #else
15548 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15549 #endif
15550 }
15551 return pyobj;
15552 }
15553
15554
15555 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15556 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15557 return 1;
15558 }
15559
15560
15561 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15562 PyObject *pyobj;
15563
15564 {
15565 #if wxUSE_UNICODE
15566 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15567 #else
15568 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15569 #endif
15570 }
15571 return pyobj;
15572 }
15573
15574
15575 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15576 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15577 return 1;
15578 }
15579
15580
15581 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15582 PyObject *pyobj;
15583
15584 {
15585 #if wxUSE_UNICODE
15586 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15587 #else
15588 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15589 #endif
15590 }
15591 return pyobj;
15592 }
15593
15594
15595 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15596 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15597 return 1;
15598 }
15599
15600
15601 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15602 PyObject *pyobj;
15603
15604 {
15605 #if wxUSE_UNICODE
15606 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15607 #else
15608 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15609 #endif
15610 }
15611 return pyobj;
15612 }
15613
15614
15615 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15616 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15617 return 1;
15618 }
15619
15620
15621 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15622 PyObject *pyobj;
15623
15624 {
15625 #if wxUSE_UNICODE
15626 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15627 #else
15628 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15629 #endif
15630 }
15631 return pyobj;
15632 }
15633
15634
15635 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15636 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15637 return 1;
15638 }
15639
15640
15641 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15642 PyObject *pyobj;
15643
15644 {
15645 #if wxUSE_UNICODE
15646 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15647 #else
15648 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15649 #endif
15650 }
15651 return pyobj;
15652 }
15653
15654
15655 static int _wrap_ART_GO_BACK_set(PyObject *) {
15656 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15657 return 1;
15658 }
15659
15660
15661 static PyObject *_wrap_ART_GO_BACK_get(void) {
15662 PyObject *pyobj;
15663
15664 {
15665 #if wxUSE_UNICODE
15666 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15667 #else
15668 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15669 #endif
15670 }
15671 return pyobj;
15672 }
15673
15674
15675 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15676 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15677 return 1;
15678 }
15679
15680
15681 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15682 PyObject *pyobj;
15683
15684 {
15685 #if wxUSE_UNICODE
15686 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15687 #else
15688 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15689 #endif
15690 }
15691 return pyobj;
15692 }
15693
15694
15695 static int _wrap_ART_GO_UP_set(PyObject *) {
15696 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15697 return 1;
15698 }
15699
15700
15701 static PyObject *_wrap_ART_GO_UP_get(void) {
15702 PyObject *pyobj;
15703
15704 {
15705 #if wxUSE_UNICODE
15706 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15707 #else
15708 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15709 #endif
15710 }
15711 return pyobj;
15712 }
15713
15714
15715 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15716 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15717 return 1;
15718 }
15719
15720
15721 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15722 PyObject *pyobj;
15723
15724 {
15725 #if wxUSE_UNICODE
15726 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15727 #else
15728 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15729 #endif
15730 }
15731 return pyobj;
15732 }
15733
15734
15735 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15736 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15737 return 1;
15738 }
15739
15740
15741 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15742 PyObject *pyobj;
15743
15744 {
15745 #if wxUSE_UNICODE
15746 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15747 #else
15748 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15749 #endif
15750 }
15751 return pyobj;
15752 }
15753
15754
15755 static int _wrap_ART_GO_HOME_set(PyObject *) {
15756 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15757 return 1;
15758 }
15759
15760
15761 static PyObject *_wrap_ART_GO_HOME_get(void) {
15762 PyObject *pyobj;
15763
15764 {
15765 #if wxUSE_UNICODE
15766 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15767 #else
15768 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15769 #endif
15770 }
15771 return pyobj;
15772 }
15773
15774
15775 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15776 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15777 return 1;
15778 }
15779
15780
15781 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15782 PyObject *pyobj;
15783
15784 {
15785 #if wxUSE_UNICODE
15786 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15787 #else
15788 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15789 #endif
15790 }
15791 return pyobj;
15792 }
15793
15794
15795 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15796 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15797 return 1;
15798 }
15799
15800
15801 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15802 PyObject *pyobj;
15803
15804 {
15805 #if wxUSE_UNICODE
15806 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15807 #else
15808 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15809 #endif
15810 }
15811 return pyobj;
15812 }
15813
15814
15815 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15816 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15817 return 1;
15818 }
15819
15820
15821 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15822 PyObject *pyobj;
15823
15824 {
15825 #if wxUSE_UNICODE
15826 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15827 #else
15828 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15829 #endif
15830 }
15831 return pyobj;
15832 }
15833
15834
15835 static int _wrap_ART_PRINT_set(PyObject *) {
15836 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15837 return 1;
15838 }
15839
15840
15841 static PyObject *_wrap_ART_PRINT_get(void) {
15842 PyObject *pyobj;
15843
15844 {
15845 #if wxUSE_UNICODE
15846 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15847 #else
15848 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15849 #endif
15850 }
15851 return pyobj;
15852 }
15853
15854
15855 static int _wrap_ART_HELP_set(PyObject *) {
15856 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15857 return 1;
15858 }
15859
15860
15861 static PyObject *_wrap_ART_HELP_get(void) {
15862 PyObject *pyobj;
15863
15864 {
15865 #if wxUSE_UNICODE
15866 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15867 #else
15868 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15869 #endif
15870 }
15871 return pyobj;
15872 }
15873
15874
15875 static int _wrap_ART_TIP_set(PyObject *) {
15876 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15877 return 1;
15878 }
15879
15880
15881 static PyObject *_wrap_ART_TIP_get(void) {
15882 PyObject *pyobj;
15883
15884 {
15885 #if wxUSE_UNICODE
15886 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15887 #else
15888 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15889 #endif
15890 }
15891 return pyobj;
15892 }
15893
15894
15895 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15896 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15897 return 1;
15898 }
15899
15900
15901 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15902 PyObject *pyobj;
15903
15904 {
15905 #if wxUSE_UNICODE
15906 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15907 #else
15908 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15909 #endif
15910 }
15911 return pyobj;
15912 }
15913
15914
15915 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15916 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15917 return 1;
15918 }
15919
15920
15921 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15922 PyObject *pyobj;
15923
15924 {
15925 #if wxUSE_UNICODE
15926 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15927 #else
15928 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15929 #endif
15930 }
15931 return pyobj;
15932 }
15933
15934
15935 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15936 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15937 return 1;
15938 }
15939
15940
15941 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15942 PyObject *pyobj;
15943
15944 {
15945 #if wxUSE_UNICODE
15946 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15947 #else
15948 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15949 #endif
15950 }
15951 return pyobj;
15952 }
15953
15954
15955 static int _wrap_ART_HARDDISK_set(PyObject *) {
15956 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15957 return 1;
15958 }
15959
15960
15961 static PyObject *_wrap_ART_HARDDISK_get(void) {
15962 PyObject *pyobj;
15963
15964 {
15965 #if wxUSE_UNICODE
15966 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15967 #else
15968 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15969 #endif
15970 }
15971 return pyobj;
15972 }
15973
15974
15975 static int _wrap_ART_FLOPPY_set(PyObject *) {
15976 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15977 return 1;
15978 }
15979
15980
15981 static PyObject *_wrap_ART_FLOPPY_get(void) {
15982 PyObject *pyobj;
15983
15984 {
15985 #if wxUSE_UNICODE
15986 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15987 #else
15988 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15989 #endif
15990 }
15991 return pyobj;
15992 }
15993
15994
15995 static int _wrap_ART_CDROM_set(PyObject *) {
15996 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
15997 return 1;
15998 }
15999
16000
16001 static PyObject *_wrap_ART_CDROM_get(void) {
16002 PyObject *pyobj;
16003
16004 {
16005 #if wxUSE_UNICODE
16006 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16007 #else
16008 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16009 #endif
16010 }
16011 return pyobj;
16012 }
16013
16014
16015 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16016 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16017 return 1;
16018 }
16019
16020
16021 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16022 PyObject *pyobj;
16023
16024 {
16025 #if wxUSE_UNICODE
16026 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16027 #else
16028 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16029 #endif
16030 }
16031 return pyobj;
16032 }
16033
16034
16035 static int _wrap_ART_FOLDER_set(PyObject *) {
16036 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16037 return 1;
16038 }
16039
16040
16041 static PyObject *_wrap_ART_FOLDER_get(void) {
16042 PyObject *pyobj;
16043
16044 {
16045 #if wxUSE_UNICODE
16046 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16047 #else
16048 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16049 #endif
16050 }
16051 return pyobj;
16052 }
16053
16054
16055 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16056 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16057 return 1;
16058 }
16059
16060
16061 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16062 PyObject *pyobj;
16063
16064 {
16065 #if wxUSE_UNICODE
16066 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16067 #else
16068 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16069 #endif
16070 }
16071 return pyobj;
16072 }
16073
16074
16075 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16076 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16077 return 1;
16078 }
16079
16080
16081 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16082 PyObject *pyobj;
16083
16084 {
16085 #if wxUSE_UNICODE
16086 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16087 #else
16088 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16089 #endif
16090 }
16091 return pyobj;
16092 }
16093
16094
16095 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16096 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16097 return 1;
16098 }
16099
16100
16101 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16102 PyObject *pyobj;
16103
16104 {
16105 #if wxUSE_UNICODE
16106 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16107 #else
16108 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16109 #endif
16110 }
16111 return pyobj;
16112 }
16113
16114
16115 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16116 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16117 return 1;
16118 }
16119
16120
16121 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16122 PyObject *pyobj;
16123
16124 {
16125 #if wxUSE_UNICODE
16126 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16127 #else
16128 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16129 #endif
16130 }
16131 return pyobj;
16132 }
16133
16134
16135 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16136 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16137 return 1;
16138 }
16139
16140
16141 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16142 PyObject *pyobj;
16143
16144 {
16145 #if wxUSE_UNICODE
16146 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16147 #else
16148 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16149 #endif
16150 }
16151 return pyobj;
16152 }
16153
16154
16155 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16156 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16157 return 1;
16158 }
16159
16160
16161 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16162 PyObject *pyobj;
16163
16164 {
16165 #if wxUSE_UNICODE
16166 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16167 #else
16168 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16169 #endif
16170 }
16171 return pyobj;
16172 }
16173
16174
16175 static int _wrap_ART_ERROR_set(PyObject *) {
16176 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16177 return 1;
16178 }
16179
16180
16181 static PyObject *_wrap_ART_ERROR_get(void) {
16182 PyObject *pyobj;
16183
16184 {
16185 #if wxUSE_UNICODE
16186 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16187 #else
16188 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16189 #endif
16190 }
16191 return pyobj;
16192 }
16193
16194
16195 static int _wrap_ART_QUESTION_set(PyObject *) {
16196 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16197 return 1;
16198 }
16199
16200
16201 static PyObject *_wrap_ART_QUESTION_get(void) {
16202 PyObject *pyobj;
16203
16204 {
16205 #if wxUSE_UNICODE
16206 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16207 #else
16208 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16209 #endif
16210 }
16211 return pyobj;
16212 }
16213
16214
16215 static int _wrap_ART_WARNING_set(PyObject *) {
16216 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16217 return 1;
16218 }
16219
16220
16221 static PyObject *_wrap_ART_WARNING_get(void) {
16222 PyObject *pyobj;
16223
16224 {
16225 #if wxUSE_UNICODE
16226 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16227 #else
16228 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16229 #endif
16230 }
16231 return pyobj;
16232 }
16233
16234
16235 static int _wrap_ART_INFORMATION_set(PyObject *) {
16236 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16237 return 1;
16238 }
16239
16240
16241 static PyObject *_wrap_ART_INFORMATION_get(void) {
16242 PyObject *pyobj;
16243
16244 {
16245 #if wxUSE_UNICODE
16246 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16247 #else
16248 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16249 #endif
16250 }
16251 return pyobj;
16252 }
16253
16254
16255 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16256 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16257 return 1;
16258 }
16259
16260
16261 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16262 PyObject *pyobj;
16263
16264 {
16265 #if wxUSE_UNICODE
16266 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16267 #else
16268 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16269 #endif
16270 }
16271 return pyobj;
16272 }
16273
16274
16275 static int _wrap_ART_COPY_set(PyObject *) {
16276 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16277 return 1;
16278 }
16279
16280
16281 static PyObject *_wrap_ART_COPY_get(void) {
16282 PyObject *pyobj;
16283
16284 {
16285 #if wxUSE_UNICODE
16286 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16287 #else
16288 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16289 #endif
16290 }
16291 return pyobj;
16292 }
16293
16294
16295 static int _wrap_ART_CUT_set(PyObject *) {
16296 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16297 return 1;
16298 }
16299
16300
16301 static PyObject *_wrap_ART_CUT_get(void) {
16302 PyObject *pyobj;
16303
16304 {
16305 #if wxUSE_UNICODE
16306 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16307 #else
16308 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16309 #endif
16310 }
16311 return pyobj;
16312 }
16313
16314
16315 static int _wrap_ART_PASTE_set(PyObject *) {
16316 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16317 return 1;
16318 }
16319
16320
16321 static PyObject *_wrap_ART_PASTE_get(void) {
16322 PyObject *pyobj;
16323
16324 {
16325 #if wxUSE_UNICODE
16326 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16327 #else
16328 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16329 #endif
16330 }
16331 return pyobj;
16332 }
16333
16334
16335 static int _wrap_ART_DELETE_set(PyObject *) {
16336 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16337 return 1;
16338 }
16339
16340
16341 static PyObject *_wrap_ART_DELETE_get(void) {
16342 PyObject *pyobj;
16343
16344 {
16345 #if wxUSE_UNICODE
16346 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16347 #else
16348 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16349 #endif
16350 }
16351 return pyobj;
16352 }
16353
16354
16355 static int _wrap_ART_UNDO_set(PyObject *) {
16356 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16357 return 1;
16358 }
16359
16360
16361 static PyObject *_wrap_ART_UNDO_get(void) {
16362 PyObject *pyobj;
16363
16364 {
16365 #if wxUSE_UNICODE
16366 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16367 #else
16368 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16369 #endif
16370 }
16371 return pyobj;
16372 }
16373
16374
16375 static int _wrap_ART_REDO_set(PyObject *) {
16376 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16377 return 1;
16378 }
16379
16380
16381 static PyObject *_wrap_ART_REDO_get(void) {
16382 PyObject *pyobj;
16383
16384 {
16385 #if wxUSE_UNICODE
16386 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16387 #else
16388 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16389 #endif
16390 }
16391 return pyobj;
16392 }
16393
16394
16395 static int _wrap_ART_QUIT_set(PyObject *) {
16396 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16397 return 1;
16398 }
16399
16400
16401 static PyObject *_wrap_ART_QUIT_get(void) {
16402 PyObject *pyobj;
16403
16404 {
16405 #if wxUSE_UNICODE
16406 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16407 #else
16408 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16409 #endif
16410 }
16411 return pyobj;
16412 }
16413
16414
16415 static int _wrap_ART_FIND_set(PyObject *) {
16416 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16417 return 1;
16418 }
16419
16420
16421 static PyObject *_wrap_ART_FIND_get(void) {
16422 PyObject *pyobj;
16423
16424 {
16425 #if wxUSE_UNICODE
16426 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16427 #else
16428 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16429 #endif
16430 }
16431 return pyobj;
16432 }
16433
16434
16435 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16436 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16437 return 1;
16438 }
16439
16440
16441 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16442 PyObject *pyobj;
16443
16444 {
16445 #if wxUSE_UNICODE
16446 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16447 #else
16448 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16449 #endif
16450 }
16451 return pyobj;
16452 }
16453
16454
16455 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16456 PyObject *resultobj;
16457 wxPyArtProvider *result;
16458 char *kwnames[] = {
16459 NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16463 {
16464 if (!wxPyCheckForApp()) SWIG_fail;
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (wxPyArtProvider *)new wxPyArtProvider();
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj;
16480 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16481 PyObject *arg2 = (PyObject *) 0 ;
16482 PyObject *arg3 = (PyObject *) 0 ;
16483 PyObject * obj0 = 0 ;
16484 PyObject * obj1 = 0 ;
16485 PyObject * obj2 = 0 ;
16486 char *kwnames[] = {
16487 (char *) "self",(char *) "self",(char *) "_class", NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16492 if (SWIG_arg_fail(1)) SWIG_fail;
16493 arg2 = obj1;
16494 arg3 = obj2;
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 (arg1)->_setCallbackInfo(arg2,arg3);
16498
16499 wxPyEndAllowThreads(__tstate);
16500 if (PyErr_Occurred()) SWIG_fail;
16501 }
16502 Py_INCREF(Py_None); resultobj = Py_None;
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16510 PyObject *resultobj;
16511 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16512 PyObject * obj0 = 0 ;
16513 char *kwnames[] = {
16514 (char *) "provider", NULL
16515 };
16516
16517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16519 if (SWIG_arg_fail(1)) SWIG_fail;
16520 {
16521 PyThreadState* __tstate = wxPyBeginAllowThreads();
16522 wxPyArtProvider::PushProvider(arg1);
16523
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 Py_INCREF(Py_None); resultobj = Py_None;
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj;
16536 bool result;
16537 char *kwnames[] = {
16538 NULL
16539 };
16540
16541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16542 {
16543 PyThreadState* __tstate = wxPyBeginAllowThreads();
16544 result = (bool)wxPyArtProvider::PopProvider();
16545
16546 wxPyEndAllowThreads(__tstate);
16547 if (PyErr_Occurred()) SWIG_fail;
16548 }
16549 {
16550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16551 }
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj;
16560 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16561 bool result;
16562 PyObject * obj0 = 0 ;
16563 char *kwnames[] = {
16564 (char *) "provider", NULL
16565 };
16566
16567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16569 if (SWIG_arg_fail(1)) SWIG_fail;
16570 {
16571 PyThreadState* __tstate = wxPyBeginAllowThreads();
16572 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16573
16574 wxPyEndAllowThreads(__tstate);
16575 if (PyErr_Occurred()) SWIG_fail;
16576 }
16577 {
16578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16579 }
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16587 PyObject *resultobj;
16588 wxString *arg1 = 0 ;
16589 wxString const &arg2_defvalue = wxPyART_OTHER ;
16590 wxString *arg2 = (wxString *) &arg2_defvalue ;
16591 wxSize const &arg3_defvalue = wxDefaultSize ;
16592 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16593 wxBitmap result;
16594 bool temp1 = false ;
16595 bool temp2 = false ;
16596 wxSize temp3 ;
16597 PyObject * obj0 = 0 ;
16598 PyObject * obj1 = 0 ;
16599 PyObject * obj2 = 0 ;
16600 char *kwnames[] = {
16601 (char *) "id",(char *) "client",(char *) "size", NULL
16602 };
16603
16604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16605 {
16606 arg1 = wxString_in_helper(obj0);
16607 if (arg1 == NULL) SWIG_fail;
16608 temp1 = true;
16609 }
16610 if (obj1) {
16611 {
16612 arg2 = wxString_in_helper(obj1);
16613 if (arg2 == NULL) SWIG_fail;
16614 temp2 = true;
16615 }
16616 }
16617 if (obj2) {
16618 {
16619 arg3 = &temp3;
16620 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16621 }
16622 }
16623 {
16624 if (!wxPyCheckForApp()) SWIG_fail;
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16627
16628 wxPyEndAllowThreads(__tstate);
16629 if (PyErr_Occurred()) SWIG_fail;
16630 }
16631 {
16632 wxBitmap * resultptr;
16633 resultptr = new wxBitmap((wxBitmap &)(result));
16634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16635 }
16636 {
16637 if (temp1)
16638 delete arg1;
16639 }
16640 {
16641 if (temp2)
16642 delete arg2;
16643 }
16644 return resultobj;
16645 fail:
16646 {
16647 if (temp1)
16648 delete arg1;
16649 }
16650 {
16651 if (temp2)
16652 delete arg2;
16653 }
16654 return NULL;
16655 }
16656
16657
16658 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj;
16660 wxString *arg1 = 0 ;
16661 wxString const &arg2_defvalue = wxPyART_OTHER ;
16662 wxString *arg2 = (wxString *) &arg2_defvalue ;
16663 wxSize const &arg3_defvalue = wxDefaultSize ;
16664 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16665 wxIcon result;
16666 bool temp1 = false ;
16667 bool temp2 = false ;
16668 wxSize temp3 ;
16669 PyObject * obj0 = 0 ;
16670 PyObject * obj1 = 0 ;
16671 PyObject * obj2 = 0 ;
16672 char *kwnames[] = {
16673 (char *) "id",(char *) "client",(char *) "size", NULL
16674 };
16675
16676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16677 {
16678 arg1 = wxString_in_helper(obj0);
16679 if (arg1 == NULL) SWIG_fail;
16680 temp1 = true;
16681 }
16682 if (obj1) {
16683 {
16684 arg2 = wxString_in_helper(obj1);
16685 if (arg2 == NULL) SWIG_fail;
16686 temp2 = true;
16687 }
16688 }
16689 if (obj2) {
16690 {
16691 arg3 = &temp3;
16692 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16693 }
16694 }
16695 {
16696 if (!wxPyCheckForApp()) SWIG_fail;
16697 PyThreadState* __tstate = wxPyBeginAllowThreads();
16698 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16699
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 {
16704 wxIcon * resultptr;
16705 resultptr = new wxIcon((wxIcon &)(result));
16706 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16707 }
16708 {
16709 if (temp1)
16710 delete arg1;
16711 }
16712 {
16713 if (temp2)
16714 delete arg2;
16715 }
16716 return resultobj;
16717 fail:
16718 {
16719 if (temp1)
16720 delete arg1;
16721 }
16722 {
16723 if (temp2)
16724 delete arg2;
16725 }
16726 return NULL;
16727 }
16728
16729
16730 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj;
16732 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16733 PyObject * obj0 = 0 ;
16734 char *kwnames[] = {
16735 (char *) "self", NULL
16736 };
16737
16738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16740 if (SWIG_arg_fail(1)) SWIG_fail;
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 wxPyArtProvider_Destroy(arg1);
16744
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 Py_INCREF(Py_None); resultobj = Py_None;
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16756 PyObject *obj;
16757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16758 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16759 Py_INCREF(obj);
16760 return Py_BuildValue((char *)"");
16761 }
16762 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16763 PyObject *resultobj;
16764 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16765 PyObject * obj0 = 0 ;
16766 char *kwnames[] = {
16767 (char *) "self", NULL
16768 };
16769
16770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16772 if (SWIG_arg_fail(1)) SWIG_fail;
16773 {
16774 PyThreadState* __tstate = wxPyBeginAllowThreads();
16775 delete arg1;
16776
16777 wxPyEndAllowThreads(__tstate);
16778 if (PyErr_Occurred()) SWIG_fail;
16779 }
16780 Py_INCREF(Py_None); resultobj = Py_None;
16781 return resultobj;
16782 fail:
16783 return NULL;
16784 }
16785
16786
16787 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16788 PyObject *resultobj;
16789 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16790 wxConfigBase *result;
16791 PyObject * obj0 = 0 ;
16792 char *kwnames[] = {
16793 (char *) "config", NULL
16794 };
16795
16796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16798 if (SWIG_arg_fail(1)) SWIG_fail;
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16802
16803 wxPyEndAllowThreads(__tstate);
16804 if (PyErr_Occurred()) SWIG_fail;
16805 }
16806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16807 return resultobj;
16808 fail:
16809 return NULL;
16810 }
16811
16812
16813 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16814 PyObject *resultobj;
16815 bool arg1 = (bool) true ;
16816 wxConfigBase *result;
16817 PyObject * obj0 = 0 ;
16818 char *kwnames[] = {
16819 (char *) "createOnDemand", NULL
16820 };
16821
16822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16823 if (obj0) {
16824 {
16825 arg1 = (bool)(SWIG_As_bool(obj0));
16826 if (SWIG_arg_fail(1)) SWIG_fail;
16827 }
16828 }
16829 {
16830 PyThreadState* __tstate = wxPyBeginAllowThreads();
16831 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16832
16833 wxPyEndAllowThreads(__tstate);
16834 if (PyErr_Occurred()) SWIG_fail;
16835 }
16836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16837 return resultobj;
16838 fail:
16839 return NULL;
16840 }
16841
16842
16843 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16844 PyObject *resultobj;
16845 wxConfigBase *result;
16846 char *kwnames[] = {
16847 NULL
16848 };
16849
16850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (wxConfigBase *)wxConfigBase::Create();
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16859 return resultobj;
16860 fail:
16861 return NULL;
16862 }
16863
16864
16865 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16866 PyObject *resultobj;
16867 char *kwnames[] = {
16868 NULL
16869 };
16870
16871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16872 {
16873 PyThreadState* __tstate = wxPyBeginAllowThreads();
16874 wxConfigBase::DontCreateOnDemand();
16875
16876 wxPyEndAllowThreads(__tstate);
16877 if (PyErr_Occurred()) SWIG_fail;
16878 }
16879 Py_INCREF(Py_None); resultobj = Py_None;
16880 return resultobj;
16881 fail:
16882 return NULL;
16883 }
16884
16885
16886 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16887 PyObject *resultobj;
16888 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16889 wxString *arg2 = 0 ;
16890 bool temp2 = false ;
16891 PyObject * obj0 = 0 ;
16892 PyObject * obj1 = 0 ;
16893 char *kwnames[] = {
16894 (char *) "self",(char *) "path", NULL
16895 };
16896
16897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16899 if (SWIG_arg_fail(1)) SWIG_fail;
16900 {
16901 arg2 = wxString_in_helper(obj1);
16902 if (arg2 == NULL) SWIG_fail;
16903 temp2 = true;
16904 }
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 (arg1)->SetPath((wxString const &)*arg2);
16908
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 Py_INCREF(Py_None); resultobj = Py_None;
16913 {
16914 if (temp2)
16915 delete arg2;
16916 }
16917 return resultobj;
16918 fail:
16919 {
16920 if (temp2)
16921 delete arg2;
16922 }
16923 return NULL;
16924 }
16925
16926
16927 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16928 PyObject *resultobj;
16929 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16930 wxString *result;
16931 PyObject * obj0 = 0 ;
16932 char *kwnames[] = {
16933 (char *) "self", NULL
16934 };
16935
16936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16938 if (SWIG_arg_fail(1)) SWIG_fail;
16939 {
16940 PyThreadState* __tstate = wxPyBeginAllowThreads();
16941 {
16942 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
16943 result = (wxString *) &_result_ref;
16944 }
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 {
16950 #if wxUSE_UNICODE
16951 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
16952 #else
16953 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
16954 #endif
16955 }
16956 return resultobj;
16957 fail:
16958 return NULL;
16959 }
16960
16961
16962 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16963 PyObject *resultobj;
16964 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16965 PyObject *result;
16966 PyObject * obj0 = 0 ;
16967 char *kwnames[] = {
16968 (char *) "self", NULL
16969 };
16970
16971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
16972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16973 if (SWIG_arg_fail(1)) SWIG_fail;
16974 {
16975 PyThreadState* __tstate = wxPyBeginAllowThreads();
16976 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
16977
16978 wxPyEndAllowThreads(__tstate);
16979 if (PyErr_Occurred()) SWIG_fail;
16980 }
16981 resultobj = result;
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16991 long arg2 ;
16992 PyObject *result;
16993 PyObject * obj0 = 0 ;
16994 PyObject * obj1 = 0 ;
16995 char *kwnames[] = {
16996 (char *) "self",(char *) "index", NULL
16997 };
16998
16999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17001 if (SWIG_arg_fail(1)) SWIG_fail;
17002 {
17003 arg2 = (long)(SWIG_As_long(obj1));
17004 if (SWIG_arg_fail(2)) SWIG_fail;
17005 }
17006 {
17007 PyThreadState* __tstate = wxPyBeginAllowThreads();
17008 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17009
17010 wxPyEndAllowThreads(__tstate);
17011 if (PyErr_Occurred()) SWIG_fail;
17012 }
17013 resultobj = result;
17014 return resultobj;
17015 fail:
17016 return NULL;
17017 }
17018
17019
17020 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17021 PyObject *resultobj;
17022 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17023 PyObject *result;
17024 PyObject * obj0 = 0 ;
17025 char *kwnames[] = {
17026 (char *) "self", NULL
17027 };
17028
17029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) goto fail;
17030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17031 if (SWIG_arg_fail(1)) SWIG_fail;
17032 {
17033 PyThreadState* __tstate = wxPyBeginAllowThreads();
17034 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17035
17036 wxPyEndAllowThreads(__tstate);
17037 if (PyErr_Occurred()) SWIG_fail;
17038 }
17039 resultobj = result;
17040 return resultobj;
17041 fail:
17042 return NULL;
17043 }
17044
17045
17046 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17047 PyObject *resultobj;
17048 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17049 long arg2 ;
17050 PyObject *result;
17051 PyObject * obj0 = 0 ;
17052 PyObject * obj1 = 0 ;
17053 char *kwnames[] = {
17054 (char *) "self",(char *) "index", NULL
17055 };
17056
17057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17059 if (SWIG_arg_fail(1)) SWIG_fail;
17060 {
17061 arg2 = (long)(SWIG_As_long(obj1));
17062 if (SWIG_arg_fail(2)) SWIG_fail;
17063 }
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17067
17068 wxPyEndAllowThreads(__tstate);
17069 if (PyErr_Occurred()) SWIG_fail;
17070 }
17071 resultobj = result;
17072 return resultobj;
17073 fail:
17074 return NULL;
17075 }
17076
17077
17078 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17079 PyObject *resultobj;
17080 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17081 bool arg2 = (bool) false ;
17082 size_t result;
17083 PyObject * obj0 = 0 ;
17084 PyObject * obj1 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self",(char *) "recursive", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 if (obj1) {
17093 {
17094 arg2 = (bool)(SWIG_As_bool(obj1));
17095 if (SWIG_arg_fail(2)) SWIG_fail;
17096 }
17097 }
17098 {
17099 PyThreadState* __tstate = wxPyBeginAllowThreads();
17100 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17101
17102 wxPyEndAllowThreads(__tstate);
17103 if (PyErr_Occurred()) SWIG_fail;
17104 }
17105 {
17106 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17107 }
17108 return resultobj;
17109 fail:
17110 return NULL;
17111 }
17112
17113
17114 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17115 PyObject *resultobj;
17116 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17117 bool arg2 = (bool) false ;
17118 size_t result;
17119 PyObject * obj0 = 0 ;
17120 PyObject * obj1 = 0 ;
17121 char *kwnames[] = {
17122 (char *) "self",(char *) "recursive", NULL
17123 };
17124
17125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17127 if (SWIG_arg_fail(1)) SWIG_fail;
17128 if (obj1) {
17129 {
17130 arg2 = (bool)(SWIG_As_bool(obj1));
17131 if (SWIG_arg_fail(2)) SWIG_fail;
17132 }
17133 }
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17137
17138 wxPyEndAllowThreads(__tstate);
17139 if (PyErr_Occurred()) SWIG_fail;
17140 }
17141 {
17142 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17143 }
17144 return resultobj;
17145 fail:
17146 return NULL;
17147 }
17148
17149
17150 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17151 PyObject *resultobj;
17152 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17153 wxString *arg2 = 0 ;
17154 bool result;
17155 bool temp2 = false ;
17156 PyObject * obj0 = 0 ;
17157 PyObject * obj1 = 0 ;
17158 char *kwnames[] = {
17159 (char *) "self",(char *) "name", NULL
17160 };
17161
17162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17164 if (SWIG_arg_fail(1)) SWIG_fail;
17165 {
17166 arg2 = wxString_in_helper(obj1);
17167 if (arg2 == NULL) SWIG_fail;
17168 temp2 = true;
17169 }
17170 {
17171 PyThreadState* __tstate = wxPyBeginAllowThreads();
17172 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17173
17174 wxPyEndAllowThreads(__tstate);
17175 if (PyErr_Occurred()) SWIG_fail;
17176 }
17177 {
17178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17179 }
17180 {
17181 if (temp2)
17182 delete arg2;
17183 }
17184 return resultobj;
17185 fail:
17186 {
17187 if (temp2)
17188 delete arg2;
17189 }
17190 return NULL;
17191 }
17192
17193
17194 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17195 PyObject *resultobj;
17196 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17197 wxString *arg2 = 0 ;
17198 bool result;
17199 bool temp2 = false ;
17200 PyObject * obj0 = 0 ;
17201 PyObject * obj1 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self",(char *) "name", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 arg2 = wxString_in_helper(obj1);
17211 if (arg2 == NULL) SWIG_fail;
17212 temp2 = true;
17213 }
17214 {
17215 PyThreadState* __tstate = wxPyBeginAllowThreads();
17216 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17217
17218 wxPyEndAllowThreads(__tstate);
17219 if (PyErr_Occurred()) SWIG_fail;
17220 }
17221 {
17222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17223 }
17224 {
17225 if (temp2)
17226 delete arg2;
17227 }
17228 return resultobj;
17229 fail:
17230 {
17231 if (temp2)
17232 delete arg2;
17233 }
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj;
17240 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17241 wxString *arg2 = 0 ;
17242 bool result;
17243 bool temp2 = false ;
17244 PyObject * obj0 = 0 ;
17245 PyObject * obj1 = 0 ;
17246 char *kwnames[] = {
17247 (char *) "self",(char *) "name", NULL
17248 };
17249
17250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17252 if (SWIG_arg_fail(1)) SWIG_fail;
17253 {
17254 arg2 = wxString_in_helper(obj1);
17255 if (arg2 == NULL) SWIG_fail;
17256 temp2 = true;
17257 }
17258 {
17259 PyThreadState* __tstate = wxPyBeginAllowThreads();
17260 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17261
17262 wxPyEndAllowThreads(__tstate);
17263 if (PyErr_Occurred()) SWIG_fail;
17264 }
17265 {
17266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17267 }
17268 {
17269 if (temp2)
17270 delete arg2;
17271 }
17272 return resultobj;
17273 fail:
17274 {
17275 if (temp2)
17276 delete arg2;
17277 }
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17285 wxString *arg2 = 0 ;
17286 wxConfigBase::EntryType result;
17287 bool temp2 = false ;
17288 PyObject * obj0 = 0 ;
17289 PyObject * obj1 = 0 ;
17290 char *kwnames[] = {
17291 (char *) "self",(char *) "name", NULL
17292 };
17293
17294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17296 if (SWIG_arg_fail(1)) SWIG_fail;
17297 {
17298 arg2 = wxString_in_helper(obj1);
17299 if (arg2 == NULL) SWIG_fail;
17300 temp2 = true;
17301 }
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17305
17306 wxPyEndAllowThreads(__tstate);
17307 if (PyErr_Occurred()) SWIG_fail;
17308 }
17309 resultobj = SWIG_From_int((result));
17310 {
17311 if (temp2)
17312 delete arg2;
17313 }
17314 return resultobj;
17315 fail:
17316 {
17317 if (temp2)
17318 delete arg2;
17319 }
17320 return NULL;
17321 }
17322
17323
17324 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17325 PyObject *resultobj;
17326 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17327 wxString *arg2 = 0 ;
17328 wxString const &arg3_defvalue = wxPyEmptyString ;
17329 wxString *arg3 = (wxString *) &arg3_defvalue ;
17330 wxString result;
17331 bool temp2 = false ;
17332 bool temp3 = false ;
17333 PyObject * obj0 = 0 ;
17334 PyObject * obj1 = 0 ;
17335 PyObject * obj2 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 arg2 = wxString_in_helper(obj1);
17345 if (arg2 == NULL) SWIG_fail;
17346 temp2 = true;
17347 }
17348 if (obj2) {
17349 {
17350 arg3 = wxString_in_helper(obj2);
17351 if (arg3 == NULL) SWIG_fail;
17352 temp3 = true;
17353 }
17354 }
17355 {
17356 PyThreadState* __tstate = wxPyBeginAllowThreads();
17357 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17358
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 {
17363 #if wxUSE_UNICODE
17364 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17365 #else
17366 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17367 #endif
17368 }
17369 {
17370 if (temp2)
17371 delete arg2;
17372 }
17373 {
17374 if (temp3)
17375 delete arg3;
17376 }
17377 return resultobj;
17378 fail:
17379 {
17380 if (temp2)
17381 delete arg2;
17382 }
17383 {
17384 if (temp3)
17385 delete arg3;
17386 }
17387 return NULL;
17388 }
17389
17390
17391 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17392 PyObject *resultobj;
17393 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17394 wxString *arg2 = 0 ;
17395 long arg3 = (long) 0 ;
17396 long result;
17397 bool temp2 = false ;
17398 PyObject * obj0 = 0 ;
17399 PyObject * obj1 = 0 ;
17400 PyObject * obj2 = 0 ;
17401 char *kwnames[] = {
17402 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17403 };
17404
17405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17407 if (SWIG_arg_fail(1)) SWIG_fail;
17408 {
17409 arg2 = wxString_in_helper(obj1);
17410 if (arg2 == NULL) SWIG_fail;
17411 temp2 = true;
17412 }
17413 if (obj2) {
17414 {
17415 arg3 = (long)(SWIG_As_long(obj2));
17416 if (SWIG_arg_fail(3)) SWIG_fail;
17417 }
17418 }
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17422
17423 wxPyEndAllowThreads(__tstate);
17424 if (PyErr_Occurred()) SWIG_fail;
17425 }
17426 {
17427 resultobj = SWIG_From_long((long)(result));
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp2)
17437 delete arg2;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj;
17445 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17446 wxString *arg2 = 0 ;
17447 double arg3 = (double) 0.0 ;
17448 double result;
17449 bool temp2 = false ;
17450 PyObject * obj0 = 0 ;
17451 PyObject * obj1 = 0 ;
17452 PyObject * obj2 = 0 ;
17453 char *kwnames[] = {
17454 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17455 };
17456
17457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17459 if (SWIG_arg_fail(1)) SWIG_fail;
17460 {
17461 arg2 = wxString_in_helper(obj1);
17462 if (arg2 == NULL) SWIG_fail;
17463 temp2 = true;
17464 }
17465 if (obj2) {
17466 {
17467 arg3 = (double)(SWIG_As_double(obj2));
17468 if (SWIG_arg_fail(3)) SWIG_fail;
17469 }
17470 }
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17474
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 {
17479 resultobj = SWIG_From_double((double)(result));
17480 }
17481 {
17482 if (temp2)
17483 delete arg2;
17484 }
17485 return resultobj;
17486 fail:
17487 {
17488 if (temp2)
17489 delete arg2;
17490 }
17491 return NULL;
17492 }
17493
17494
17495 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj;
17497 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17498 wxString *arg2 = 0 ;
17499 bool arg3 = (bool) false ;
17500 bool result;
17501 bool temp2 = false ;
17502 PyObject * obj0 = 0 ;
17503 PyObject * obj1 = 0 ;
17504 PyObject * obj2 = 0 ;
17505 char *kwnames[] = {
17506 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17507 };
17508
17509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17511 if (SWIG_arg_fail(1)) SWIG_fail;
17512 {
17513 arg2 = wxString_in_helper(obj1);
17514 if (arg2 == NULL) SWIG_fail;
17515 temp2 = true;
17516 }
17517 if (obj2) {
17518 {
17519 arg3 = (bool)(SWIG_As_bool(obj2));
17520 if (SWIG_arg_fail(3)) SWIG_fail;
17521 }
17522 }
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17526
17527 wxPyEndAllowThreads(__tstate);
17528 if (PyErr_Occurred()) SWIG_fail;
17529 }
17530 {
17531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17532 }
17533 {
17534 if (temp2)
17535 delete arg2;
17536 }
17537 return resultobj;
17538 fail:
17539 {
17540 if (temp2)
17541 delete arg2;
17542 }
17543 return NULL;
17544 }
17545
17546
17547 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17548 PyObject *resultobj;
17549 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17550 wxString *arg2 = 0 ;
17551 wxString *arg3 = 0 ;
17552 bool result;
17553 bool temp2 = false ;
17554 bool temp3 = false ;
17555 PyObject * obj0 = 0 ;
17556 PyObject * obj1 = 0 ;
17557 PyObject * obj2 = 0 ;
17558 char *kwnames[] = {
17559 (char *) "self",(char *) "key",(char *) "value", NULL
17560 };
17561
17562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17564 if (SWIG_arg_fail(1)) SWIG_fail;
17565 {
17566 arg2 = wxString_in_helper(obj1);
17567 if (arg2 == NULL) SWIG_fail;
17568 temp2 = true;
17569 }
17570 {
17571 arg3 = wxString_in_helper(obj2);
17572 if (arg3 == NULL) SWIG_fail;
17573 temp3 = true;
17574 }
17575 {
17576 PyThreadState* __tstate = wxPyBeginAllowThreads();
17577 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17578
17579 wxPyEndAllowThreads(__tstate);
17580 if (PyErr_Occurred()) SWIG_fail;
17581 }
17582 {
17583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17584 }
17585 {
17586 if (temp2)
17587 delete arg2;
17588 }
17589 {
17590 if (temp3)
17591 delete arg3;
17592 }
17593 return resultobj;
17594 fail:
17595 {
17596 if (temp2)
17597 delete arg2;
17598 }
17599 {
17600 if (temp3)
17601 delete arg3;
17602 }
17603 return NULL;
17604 }
17605
17606
17607 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17608 PyObject *resultobj;
17609 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17610 wxString *arg2 = 0 ;
17611 long arg3 ;
17612 bool result;
17613 bool temp2 = false ;
17614 PyObject * obj0 = 0 ;
17615 PyObject * obj1 = 0 ;
17616 PyObject * obj2 = 0 ;
17617 char *kwnames[] = {
17618 (char *) "self",(char *) "key",(char *) "value", NULL
17619 };
17620
17621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17623 if (SWIG_arg_fail(1)) SWIG_fail;
17624 {
17625 arg2 = wxString_in_helper(obj1);
17626 if (arg2 == NULL) SWIG_fail;
17627 temp2 = true;
17628 }
17629 {
17630 arg3 = (long)(SWIG_As_long(obj2));
17631 if (SWIG_arg_fail(3)) SWIG_fail;
17632 }
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17636
17637 wxPyEndAllowThreads(__tstate);
17638 if (PyErr_Occurred()) SWIG_fail;
17639 }
17640 {
17641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17642 }
17643 {
17644 if (temp2)
17645 delete arg2;
17646 }
17647 return resultobj;
17648 fail:
17649 {
17650 if (temp2)
17651 delete arg2;
17652 }
17653 return NULL;
17654 }
17655
17656
17657 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17658 PyObject *resultobj;
17659 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17660 wxString *arg2 = 0 ;
17661 double arg3 ;
17662 bool result;
17663 bool temp2 = false ;
17664 PyObject * obj0 = 0 ;
17665 PyObject * obj1 = 0 ;
17666 PyObject * obj2 = 0 ;
17667 char *kwnames[] = {
17668 (char *) "self",(char *) "key",(char *) "value", NULL
17669 };
17670
17671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17673 if (SWIG_arg_fail(1)) SWIG_fail;
17674 {
17675 arg2 = wxString_in_helper(obj1);
17676 if (arg2 == NULL) SWIG_fail;
17677 temp2 = true;
17678 }
17679 {
17680 arg3 = (double)(SWIG_As_double(obj2));
17681 if (SWIG_arg_fail(3)) SWIG_fail;
17682 }
17683 {
17684 PyThreadState* __tstate = wxPyBeginAllowThreads();
17685 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17686
17687 wxPyEndAllowThreads(__tstate);
17688 if (PyErr_Occurred()) SWIG_fail;
17689 }
17690 {
17691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17692 }
17693 {
17694 if (temp2)
17695 delete arg2;
17696 }
17697 return resultobj;
17698 fail:
17699 {
17700 if (temp2)
17701 delete arg2;
17702 }
17703 return NULL;
17704 }
17705
17706
17707 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17708 PyObject *resultobj;
17709 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17710 wxString *arg2 = 0 ;
17711 bool arg3 ;
17712 bool result;
17713 bool temp2 = false ;
17714 PyObject * obj0 = 0 ;
17715 PyObject * obj1 = 0 ;
17716 PyObject * obj2 = 0 ;
17717 char *kwnames[] = {
17718 (char *) "self",(char *) "key",(char *) "value", NULL
17719 };
17720
17721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17723 if (SWIG_arg_fail(1)) SWIG_fail;
17724 {
17725 arg2 = wxString_in_helper(obj1);
17726 if (arg2 == NULL) SWIG_fail;
17727 temp2 = true;
17728 }
17729 {
17730 arg3 = (bool)(SWIG_As_bool(obj2));
17731 if (SWIG_arg_fail(3)) SWIG_fail;
17732 }
17733 {
17734 PyThreadState* __tstate = wxPyBeginAllowThreads();
17735 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17736
17737 wxPyEndAllowThreads(__tstate);
17738 if (PyErr_Occurred()) SWIG_fail;
17739 }
17740 {
17741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17742 }
17743 {
17744 if (temp2)
17745 delete arg2;
17746 }
17747 return resultobj;
17748 fail:
17749 {
17750 if (temp2)
17751 delete arg2;
17752 }
17753 return NULL;
17754 }
17755
17756
17757 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17758 PyObject *resultobj;
17759 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17760 bool arg2 = (bool) false ;
17761 bool result;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 char *kwnames[] = {
17765 (char *) "self",(char *) "currentOnly", NULL
17766 };
17767
17768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17770 if (SWIG_arg_fail(1)) SWIG_fail;
17771 if (obj1) {
17772 {
17773 arg2 = (bool)(SWIG_As_bool(obj1));
17774 if (SWIG_arg_fail(2)) SWIG_fail;
17775 }
17776 }
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = (bool)(arg1)->Flush(arg2);
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17786 }
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_ConfigBase_RenameEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj;
17795 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17796 wxString *arg2 = 0 ;
17797 wxString *arg3 = 0 ;
17798 bool result;
17799 bool temp2 = false ;
17800 bool temp3 = false ;
17801 PyObject * obj0 = 0 ;
17802 PyObject * obj1 = 0 ;
17803 PyObject * obj2 = 0 ;
17804 char *kwnames[] = {
17805 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17806 };
17807
17808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17810 if (SWIG_arg_fail(1)) SWIG_fail;
17811 {
17812 arg2 = wxString_in_helper(obj1);
17813 if (arg2 == NULL) SWIG_fail;
17814 temp2 = true;
17815 }
17816 {
17817 arg3 = wxString_in_helper(obj2);
17818 if (arg3 == NULL) SWIG_fail;
17819 temp3 = true;
17820 }
17821 {
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 result = (bool)(arg1)->RenameEntry((wxString const &)*arg2,(wxString const &)*arg3);
17824
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 {
17829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17830 }
17831 {
17832 if (temp2)
17833 delete arg2;
17834 }
17835 {
17836 if (temp3)
17837 delete arg3;
17838 }
17839 return resultobj;
17840 fail:
17841 {
17842 if (temp2)
17843 delete arg2;
17844 }
17845 {
17846 if (temp3)
17847 delete arg3;
17848 }
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_ConfigBase_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17854 PyObject *resultobj;
17855 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17856 wxString *arg2 = 0 ;
17857 wxString *arg3 = 0 ;
17858 bool result;
17859 bool temp2 = false ;
17860 bool temp3 = false ;
17861 PyObject * obj0 = 0 ;
17862 PyObject * obj1 = 0 ;
17863 PyObject * obj2 = 0 ;
17864 char *kwnames[] = {
17865 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17866 };
17867
17868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17870 if (SWIG_arg_fail(1)) SWIG_fail;
17871 {
17872 arg2 = wxString_in_helper(obj1);
17873 if (arg2 == NULL) SWIG_fail;
17874 temp2 = true;
17875 }
17876 {
17877 arg3 = wxString_in_helper(obj2);
17878 if (arg3 == NULL) SWIG_fail;
17879 temp3 = true;
17880 }
17881 {
17882 PyThreadState* __tstate = wxPyBeginAllowThreads();
17883 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*arg3);
17884
17885 wxPyEndAllowThreads(__tstate);
17886 if (PyErr_Occurred()) SWIG_fail;
17887 }
17888 {
17889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17890 }
17891 {
17892 if (temp2)
17893 delete arg2;
17894 }
17895 {
17896 if (temp3)
17897 delete arg3;
17898 }
17899 return resultobj;
17900 fail:
17901 {
17902 if (temp2)
17903 delete arg2;
17904 }
17905 {
17906 if (temp3)
17907 delete arg3;
17908 }
17909 return NULL;
17910 }
17911
17912
17913 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj;
17915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17916 wxString *arg2 = 0 ;
17917 bool arg3 = (bool) true ;
17918 bool result;
17919 bool temp2 = false ;
17920 PyObject * obj0 = 0 ;
17921 PyObject * obj1 = 0 ;
17922 PyObject * obj2 = 0 ;
17923 char *kwnames[] = {
17924 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17929 if (SWIG_arg_fail(1)) SWIG_fail;
17930 {
17931 arg2 = wxString_in_helper(obj1);
17932 if (arg2 == NULL) SWIG_fail;
17933 temp2 = true;
17934 }
17935 if (obj2) {
17936 {
17937 arg3 = (bool)(SWIG_As_bool(obj2));
17938 if (SWIG_arg_fail(3)) SWIG_fail;
17939 }
17940 }
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 {
17949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17950 }
17951 {
17952 if (temp2)
17953 delete arg2;
17954 }
17955 return resultobj;
17956 fail:
17957 {
17958 if (temp2)
17959 delete arg2;
17960 }
17961 return NULL;
17962 }
17963
17964
17965 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17966 PyObject *resultobj;
17967 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17968 wxString *arg2 = 0 ;
17969 bool result;
17970 bool temp2 = false ;
17971 PyObject * obj0 = 0 ;
17972 PyObject * obj1 = 0 ;
17973 char *kwnames[] = {
17974 (char *) "self",(char *) "key", NULL
17975 };
17976
17977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
17978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17979 if (SWIG_arg_fail(1)) SWIG_fail;
17980 {
17981 arg2 = wxString_in_helper(obj1);
17982 if (arg2 == NULL) SWIG_fail;
17983 temp2 = true;
17984 }
17985 {
17986 PyThreadState* __tstate = wxPyBeginAllowThreads();
17987 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
17988
17989 wxPyEndAllowThreads(__tstate);
17990 if (PyErr_Occurred()) SWIG_fail;
17991 }
17992 {
17993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17994 }
17995 {
17996 if (temp2)
17997 delete arg2;
17998 }
17999 return resultobj;
18000 fail:
18001 {
18002 if (temp2)
18003 delete arg2;
18004 }
18005 return NULL;
18006 }
18007
18008
18009 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18010 PyObject *resultobj;
18011 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18012 bool result;
18013 PyObject * obj0 = 0 ;
18014 char *kwnames[] = {
18015 (char *) "self", NULL
18016 };
18017
18018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18020 if (SWIG_arg_fail(1)) SWIG_fail;
18021 {
18022 PyThreadState* __tstate = wxPyBeginAllowThreads();
18023 result = (bool)(arg1)->DeleteAll();
18024
18025 wxPyEndAllowThreads(__tstate);
18026 if (PyErr_Occurred()) SWIG_fail;
18027 }
18028 {
18029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18030 }
18031 return resultobj;
18032 fail:
18033 return NULL;
18034 }
18035
18036
18037 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18038 PyObject *resultobj;
18039 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18040 bool arg2 = (bool) true ;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 char *kwnames[] = {
18044 (char *) "self",(char *) "doIt", NULL
18045 };
18046
18047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18049 if (SWIG_arg_fail(1)) SWIG_fail;
18050 if (obj1) {
18051 {
18052 arg2 = (bool)(SWIG_As_bool(obj1));
18053 if (SWIG_arg_fail(2)) SWIG_fail;
18054 }
18055 }
18056 {
18057 PyThreadState* __tstate = wxPyBeginAllowThreads();
18058 (arg1)->SetExpandEnvVars(arg2);
18059
18060 wxPyEndAllowThreads(__tstate);
18061 if (PyErr_Occurred()) SWIG_fail;
18062 }
18063 Py_INCREF(Py_None); resultobj = Py_None;
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj;
18072 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18073 bool result;
18074 PyObject * obj0 = 0 ;
18075 char *kwnames[] = {
18076 (char *) "self", NULL
18077 };
18078
18079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18081 if (SWIG_arg_fail(1)) SWIG_fail;
18082 {
18083 PyThreadState* __tstate = wxPyBeginAllowThreads();
18084 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18085
18086 wxPyEndAllowThreads(__tstate);
18087 if (PyErr_Occurred()) SWIG_fail;
18088 }
18089 {
18090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18091 }
18092 return resultobj;
18093 fail:
18094 return NULL;
18095 }
18096
18097
18098 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18099 PyObject *resultobj;
18100 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18101 bool arg2 = (bool) true ;
18102 PyObject * obj0 = 0 ;
18103 PyObject * obj1 = 0 ;
18104 char *kwnames[] = {
18105 (char *) "self",(char *) "doIt", NULL
18106 };
18107
18108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18110 if (SWIG_arg_fail(1)) SWIG_fail;
18111 if (obj1) {
18112 {
18113 arg2 = (bool)(SWIG_As_bool(obj1));
18114 if (SWIG_arg_fail(2)) SWIG_fail;
18115 }
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 (arg1)->SetRecordDefaults(arg2);
18120
18121 wxPyEndAllowThreads(__tstate);
18122 if (PyErr_Occurred()) SWIG_fail;
18123 }
18124 Py_INCREF(Py_None); resultobj = Py_None;
18125 return resultobj;
18126 fail:
18127 return NULL;
18128 }
18129
18130
18131 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18132 PyObject *resultobj;
18133 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18134 bool result;
18135 PyObject * obj0 = 0 ;
18136 char *kwnames[] = {
18137 (char *) "self", NULL
18138 };
18139
18140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18142 if (SWIG_arg_fail(1)) SWIG_fail;
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18146
18147 wxPyEndAllowThreads(__tstate);
18148 if (PyErr_Occurred()) SWIG_fail;
18149 }
18150 {
18151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18152 }
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18160 PyObject *resultobj;
18161 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18162 wxString *arg2 = 0 ;
18163 wxString result;
18164 bool temp2 = false ;
18165 PyObject * obj0 = 0 ;
18166 PyObject * obj1 = 0 ;
18167 char *kwnames[] = {
18168 (char *) "self",(char *) "str", NULL
18169 };
18170
18171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18173 if (SWIG_arg_fail(1)) SWIG_fail;
18174 {
18175 arg2 = wxString_in_helper(obj1);
18176 if (arg2 == NULL) SWIG_fail;
18177 temp2 = true;
18178 }
18179 {
18180 PyThreadState* __tstate = wxPyBeginAllowThreads();
18181 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18182
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 {
18187 #if wxUSE_UNICODE
18188 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18189 #else
18190 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18191 #endif
18192 }
18193 {
18194 if (temp2)
18195 delete arg2;
18196 }
18197 return resultobj;
18198 fail:
18199 {
18200 if (temp2)
18201 delete arg2;
18202 }
18203 return NULL;
18204 }
18205
18206
18207 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18208 PyObject *resultobj;
18209 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18210 wxString result;
18211 PyObject * obj0 = 0 ;
18212 char *kwnames[] = {
18213 (char *) "self", NULL
18214 };
18215
18216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18218 if (SWIG_arg_fail(1)) SWIG_fail;
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 result = ((wxConfigBase const *)arg1)->GetAppName();
18222
18223 wxPyEndAllowThreads(__tstate);
18224 if (PyErr_Occurred()) SWIG_fail;
18225 }
18226 {
18227 #if wxUSE_UNICODE
18228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18229 #else
18230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18231 #endif
18232 }
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj;
18241 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18242 wxString result;
18243 PyObject * obj0 = 0 ;
18244 char *kwnames[] = {
18245 (char *) "self", NULL
18246 };
18247
18248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18250 if (SWIG_arg_fail(1)) SWIG_fail;
18251 {
18252 PyThreadState* __tstate = wxPyBeginAllowThreads();
18253 result = ((wxConfigBase const *)arg1)->GetVendorName();
18254
18255 wxPyEndAllowThreads(__tstate);
18256 if (PyErr_Occurred()) SWIG_fail;
18257 }
18258 {
18259 #if wxUSE_UNICODE
18260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18261 #else
18262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18263 #endif
18264 }
18265 return resultobj;
18266 fail:
18267 return NULL;
18268 }
18269
18270
18271 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18272 PyObject *resultobj;
18273 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18274 wxString *arg2 = 0 ;
18275 bool temp2 = false ;
18276 PyObject * obj0 = 0 ;
18277 PyObject * obj1 = 0 ;
18278 char *kwnames[] = {
18279 (char *) "self",(char *) "appName", NULL
18280 };
18281
18282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18284 if (SWIG_arg_fail(1)) SWIG_fail;
18285 {
18286 arg2 = wxString_in_helper(obj1);
18287 if (arg2 == NULL) SWIG_fail;
18288 temp2 = true;
18289 }
18290 {
18291 PyThreadState* __tstate = wxPyBeginAllowThreads();
18292 (arg1)->SetAppName((wxString const &)*arg2);
18293
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 Py_INCREF(Py_None); resultobj = Py_None;
18298 {
18299 if (temp2)
18300 delete arg2;
18301 }
18302 return resultobj;
18303 fail:
18304 {
18305 if (temp2)
18306 delete arg2;
18307 }
18308 return NULL;
18309 }
18310
18311
18312 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18313 PyObject *resultobj;
18314 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18315 wxString *arg2 = 0 ;
18316 bool temp2 = false ;
18317 PyObject * obj0 = 0 ;
18318 PyObject * obj1 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self",(char *) "vendorName", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 {
18327 arg2 = wxString_in_helper(obj1);
18328 if (arg2 == NULL) SWIG_fail;
18329 temp2 = true;
18330 }
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 (arg1)->SetVendorName((wxString const &)*arg2);
18334
18335 wxPyEndAllowThreads(__tstate);
18336 if (PyErr_Occurred()) SWIG_fail;
18337 }
18338 Py_INCREF(Py_None); resultobj = Py_None;
18339 {
18340 if (temp2)
18341 delete arg2;
18342 }
18343 return resultobj;
18344 fail:
18345 {
18346 if (temp2)
18347 delete arg2;
18348 }
18349 return NULL;
18350 }
18351
18352
18353 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18354 PyObject *resultobj;
18355 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18356 long arg2 ;
18357 PyObject * obj0 = 0 ;
18358 PyObject * obj1 = 0 ;
18359 char *kwnames[] = {
18360 (char *) "self",(char *) "style", NULL
18361 };
18362
18363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18365 if (SWIG_arg_fail(1)) SWIG_fail;
18366 {
18367 arg2 = (long)(SWIG_As_long(obj1));
18368 if (SWIG_arg_fail(2)) SWIG_fail;
18369 }
18370 {
18371 PyThreadState* __tstate = wxPyBeginAllowThreads();
18372 (arg1)->SetStyle(arg2);
18373
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 Py_INCREF(Py_None); resultobj = Py_None;
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18387 long result;
18388 PyObject * obj0 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 {
18397 PyThreadState* __tstate = wxPyBeginAllowThreads();
18398 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18399
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 {
18404 resultobj = SWIG_From_long((long)(result));
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18413 PyObject *obj;
18414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18415 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18416 Py_INCREF(obj);
18417 return Py_BuildValue((char *)"");
18418 }
18419 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18420 PyObject *resultobj;
18421 wxString const &arg1_defvalue = wxPyEmptyString ;
18422 wxString *arg1 = (wxString *) &arg1_defvalue ;
18423 wxString const &arg2_defvalue = wxPyEmptyString ;
18424 wxString *arg2 = (wxString *) &arg2_defvalue ;
18425 wxString const &arg3_defvalue = wxPyEmptyString ;
18426 wxString *arg3 = (wxString *) &arg3_defvalue ;
18427 wxString const &arg4_defvalue = wxPyEmptyString ;
18428 wxString *arg4 = (wxString *) &arg4_defvalue ;
18429 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18430 wxConfig *result;
18431 bool temp1 = false ;
18432 bool temp2 = false ;
18433 bool temp3 = false ;
18434 bool temp4 = false ;
18435 PyObject * obj0 = 0 ;
18436 PyObject * obj1 = 0 ;
18437 PyObject * obj2 = 0 ;
18438 PyObject * obj3 = 0 ;
18439 PyObject * obj4 = 0 ;
18440 char *kwnames[] = {
18441 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18442 };
18443
18444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18445 if (obj0) {
18446 {
18447 arg1 = wxString_in_helper(obj0);
18448 if (arg1 == NULL) SWIG_fail;
18449 temp1 = true;
18450 }
18451 }
18452 if (obj1) {
18453 {
18454 arg2 = wxString_in_helper(obj1);
18455 if (arg2 == NULL) SWIG_fail;
18456 temp2 = true;
18457 }
18458 }
18459 if (obj2) {
18460 {
18461 arg3 = wxString_in_helper(obj2);
18462 if (arg3 == NULL) SWIG_fail;
18463 temp3 = true;
18464 }
18465 }
18466 if (obj3) {
18467 {
18468 arg4 = wxString_in_helper(obj3);
18469 if (arg4 == NULL) SWIG_fail;
18470 temp4 = true;
18471 }
18472 }
18473 if (obj4) {
18474 {
18475 arg5 = (long)(SWIG_As_long(obj4));
18476 if (SWIG_arg_fail(5)) SWIG_fail;
18477 }
18478 }
18479 {
18480 PyThreadState* __tstate = wxPyBeginAllowThreads();
18481 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18482
18483 wxPyEndAllowThreads(__tstate);
18484 if (PyErr_Occurred()) SWIG_fail;
18485 }
18486 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18487 {
18488 if (temp1)
18489 delete arg1;
18490 }
18491 {
18492 if (temp2)
18493 delete arg2;
18494 }
18495 {
18496 if (temp3)
18497 delete arg3;
18498 }
18499 {
18500 if (temp4)
18501 delete arg4;
18502 }
18503 return resultobj;
18504 fail:
18505 {
18506 if (temp1)
18507 delete arg1;
18508 }
18509 {
18510 if (temp2)
18511 delete arg2;
18512 }
18513 {
18514 if (temp3)
18515 delete arg3;
18516 }
18517 {
18518 if (temp4)
18519 delete arg4;
18520 }
18521 return NULL;
18522 }
18523
18524
18525 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18526 PyObject *resultobj;
18527 wxConfig *arg1 = (wxConfig *) 0 ;
18528 PyObject * obj0 = 0 ;
18529 char *kwnames[] = {
18530 (char *) "self", NULL
18531 };
18532
18533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18535 if (SWIG_arg_fail(1)) SWIG_fail;
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 delete arg1;
18539
18540 wxPyEndAllowThreads(__tstate);
18541 if (PyErr_Occurred()) SWIG_fail;
18542 }
18543 Py_INCREF(Py_None); resultobj = Py_None;
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18551 PyObject *obj;
18552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18553 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18554 Py_INCREF(obj);
18555 return Py_BuildValue((char *)"");
18556 }
18557 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18558 PyObject *resultobj;
18559 wxString const &arg1_defvalue = wxPyEmptyString ;
18560 wxString *arg1 = (wxString *) &arg1_defvalue ;
18561 wxString const &arg2_defvalue = wxPyEmptyString ;
18562 wxString *arg2 = (wxString *) &arg2_defvalue ;
18563 wxString const &arg3_defvalue = wxPyEmptyString ;
18564 wxString *arg3 = (wxString *) &arg3_defvalue ;
18565 wxString const &arg4_defvalue = wxPyEmptyString ;
18566 wxString *arg4 = (wxString *) &arg4_defvalue ;
18567 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18568 wxFileConfig *result;
18569 bool temp1 = false ;
18570 bool temp2 = false ;
18571 bool temp3 = false ;
18572 bool temp4 = false ;
18573 PyObject * obj0 = 0 ;
18574 PyObject * obj1 = 0 ;
18575 PyObject * obj2 = 0 ;
18576 PyObject * obj3 = 0 ;
18577 PyObject * obj4 = 0 ;
18578 char *kwnames[] = {
18579 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18580 };
18581
18582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18583 if (obj0) {
18584 {
18585 arg1 = wxString_in_helper(obj0);
18586 if (arg1 == NULL) SWIG_fail;
18587 temp1 = true;
18588 }
18589 }
18590 if (obj1) {
18591 {
18592 arg2 = wxString_in_helper(obj1);
18593 if (arg2 == NULL) SWIG_fail;
18594 temp2 = true;
18595 }
18596 }
18597 if (obj2) {
18598 {
18599 arg3 = wxString_in_helper(obj2);
18600 if (arg3 == NULL) SWIG_fail;
18601 temp3 = true;
18602 }
18603 }
18604 if (obj3) {
18605 {
18606 arg4 = wxString_in_helper(obj3);
18607 if (arg4 == NULL) SWIG_fail;
18608 temp4 = true;
18609 }
18610 }
18611 if (obj4) {
18612 {
18613 arg5 = (long)(SWIG_As_long(obj4));
18614 if (SWIG_arg_fail(5)) SWIG_fail;
18615 }
18616 }
18617 {
18618 PyThreadState* __tstate = wxPyBeginAllowThreads();
18619 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18620
18621 wxPyEndAllowThreads(__tstate);
18622 if (PyErr_Occurred()) SWIG_fail;
18623 }
18624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18625 {
18626 if (temp1)
18627 delete arg1;
18628 }
18629 {
18630 if (temp2)
18631 delete arg2;
18632 }
18633 {
18634 if (temp3)
18635 delete arg3;
18636 }
18637 {
18638 if (temp4)
18639 delete arg4;
18640 }
18641 return resultobj;
18642 fail:
18643 {
18644 if (temp1)
18645 delete arg1;
18646 }
18647 {
18648 if (temp2)
18649 delete arg2;
18650 }
18651 {
18652 if (temp3)
18653 delete arg3;
18654 }
18655 {
18656 if (temp4)
18657 delete arg4;
18658 }
18659 return NULL;
18660 }
18661
18662
18663 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj;
18665 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18666 PyObject * obj0 = 0 ;
18667 char *kwnames[] = {
18668 (char *) "self", NULL
18669 };
18670
18671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18673 if (SWIG_arg_fail(1)) SWIG_fail;
18674 {
18675 PyThreadState* __tstate = wxPyBeginAllowThreads();
18676 delete arg1;
18677
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 Py_INCREF(Py_None); resultobj = Py_None;
18682 return resultobj;
18683 fail:
18684 return NULL;
18685 }
18686
18687
18688 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18689 PyObject *obj;
18690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18691 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18692 Py_INCREF(obj);
18693 return Py_BuildValue((char *)"");
18694 }
18695 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18696 PyObject *resultobj;
18697 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18698 wxString *arg2 = 0 ;
18699 wxConfigPathChanger *result;
18700 bool temp2 = false ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "config",(char *) "entry", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 {
18711 arg2 = wxString_in_helper(obj1);
18712 if (arg2 == NULL) SWIG_fail;
18713 temp2 = true;
18714 }
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18718
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18723 {
18724 if (temp2)
18725 delete arg2;
18726 }
18727 return resultobj;
18728 fail:
18729 {
18730 if (temp2)
18731 delete arg2;
18732 }
18733 return NULL;
18734 }
18735
18736
18737 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18738 PyObject *resultobj;
18739 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18740 PyObject * obj0 = 0 ;
18741 char *kwnames[] = {
18742 (char *) "self", NULL
18743 };
18744
18745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18747 if (SWIG_arg_fail(1)) SWIG_fail;
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 delete arg1;
18751
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 Py_INCREF(Py_None); resultobj = Py_None;
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj;
18764 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18765 wxString *result;
18766 PyObject * obj0 = 0 ;
18767 char *kwnames[] = {
18768 (char *) "self", NULL
18769 };
18770
18771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18773 if (SWIG_arg_fail(1)) SWIG_fail;
18774 {
18775 PyThreadState* __tstate = wxPyBeginAllowThreads();
18776 {
18777 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18778 result = (wxString *) &_result_ref;
18779 }
18780
18781 wxPyEndAllowThreads(__tstate);
18782 if (PyErr_Occurred()) SWIG_fail;
18783 }
18784 {
18785 #if wxUSE_UNICODE
18786 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18787 #else
18788 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18789 #endif
18790 }
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18798 PyObject *obj;
18799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18800 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18801 Py_INCREF(obj);
18802 return Py_BuildValue((char *)"");
18803 }
18804 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj;
18806 wxString *arg1 = 0 ;
18807 wxString result;
18808 bool temp1 = false ;
18809 PyObject * obj0 = 0 ;
18810 char *kwnames[] = {
18811 (char *) "sz", NULL
18812 };
18813
18814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18815 {
18816 arg1 = wxString_in_helper(obj0);
18817 if (arg1 == NULL) SWIG_fail;
18818 temp1 = true;
18819 }
18820 {
18821 PyThreadState* __tstate = wxPyBeginAllowThreads();
18822 result = wxExpandEnvVars((wxString const &)*arg1);
18823
18824 wxPyEndAllowThreads(__tstate);
18825 if (PyErr_Occurred()) SWIG_fail;
18826 }
18827 {
18828 #if wxUSE_UNICODE
18829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18830 #else
18831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18832 #endif
18833 }
18834 {
18835 if (temp1)
18836 delete arg1;
18837 }
18838 return resultobj;
18839 fail:
18840 {
18841 if (temp1)
18842 delete arg1;
18843 }
18844 return NULL;
18845 }
18846
18847
18848 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18849 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18850 return 1;
18851 }
18852
18853
18854 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18855 PyObject *pyobj;
18856
18857 {
18858 #if wxUSE_UNICODE
18859 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18860 #else
18861 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18862 #endif
18863 }
18864 return pyobj;
18865 }
18866
18867
18868 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18869 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18870 return 1;
18871 }
18872
18873
18874 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18875 PyObject *pyobj;
18876
18877 {
18878 #if wxUSE_UNICODE
18879 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18880 #else
18881 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18882 #endif
18883 }
18884 return pyobj;
18885 }
18886
18887
18888 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18889 PyObject *resultobj;
18890 wxDateTime::Country arg1 ;
18891 PyObject * obj0 = 0 ;
18892 char *kwnames[] = {
18893 (char *) "country", NULL
18894 };
18895
18896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18897 {
18898 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18899 if (SWIG_arg_fail(1)) SWIG_fail;
18900 }
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18904
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 Py_INCREF(Py_None); resultobj = Py_None;
18909 return resultobj;
18910 fail:
18911 return NULL;
18912 }
18913
18914
18915 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18916 PyObject *resultobj;
18917 wxDateTime::Country result;
18918 char *kwnames[] = {
18919 NULL
18920 };
18921
18922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18923 {
18924 PyThreadState* __tstate = wxPyBeginAllowThreads();
18925 result = (wxDateTime::Country)wxDateTime::GetCountry();
18926
18927 wxPyEndAllowThreads(__tstate);
18928 if (PyErr_Occurred()) SWIG_fail;
18929 }
18930 resultobj = SWIG_From_int((result));
18931 return resultobj;
18932 fail:
18933 return NULL;
18934 }
18935
18936
18937 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18938 PyObject *resultobj;
18939 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
18940 bool result;
18941 PyObject * obj0 = 0 ;
18942 char *kwnames[] = {
18943 (char *) "country", NULL
18944 };
18945
18946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
18947 if (obj0) {
18948 {
18949 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18950 if (SWIG_arg_fail(1)) SWIG_fail;
18951 }
18952 }
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
18956
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 {
18961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18962 }
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj;
18971 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
18972 int result;
18973 PyObject * obj0 = 0 ;
18974 char *kwnames[] = {
18975 (char *) "cal", NULL
18976 };
18977
18978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
18979 if (obj0) {
18980 {
18981 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
18982 if (SWIG_arg_fail(1)) SWIG_fail;
18983 }
18984 }
18985 {
18986 PyThreadState* __tstate = wxPyBeginAllowThreads();
18987 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
18988
18989 wxPyEndAllowThreads(__tstate);
18990 if (PyErr_Occurred()) SWIG_fail;
18991 }
18992 {
18993 resultobj = SWIG_From_int((int)(result));
18994 }
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj;
19003 int arg1 ;
19004 int result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "year", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19011 {
19012 arg1 = (int)(SWIG_As_int(obj0));
19013 if (SWIG_arg_fail(1)) SWIG_fail;
19014 }
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = (int)wxDateTime::ConvertYearToBC(arg1);
19018
19019 wxPyEndAllowThreads(__tstate);
19020 if (PyErr_Occurred()) SWIG_fail;
19021 }
19022 {
19023 resultobj = SWIG_From_int((int)(result));
19024 }
19025 return resultobj;
19026 fail:
19027 return NULL;
19028 }
19029
19030
19031 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19032 PyObject *resultobj;
19033 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19034 wxDateTime::Month result;
19035 PyObject * obj0 = 0 ;
19036 char *kwnames[] = {
19037 (char *) "cal", NULL
19038 };
19039
19040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19041 if (obj0) {
19042 {
19043 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19044 if (SWIG_arg_fail(1)) SWIG_fail;
19045 }
19046 }
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19050
19051 wxPyEndAllowThreads(__tstate);
19052 if (PyErr_Occurred()) SWIG_fail;
19053 }
19054 resultobj = SWIG_From_int((result));
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19062 PyObject *resultobj;
19063 int arg1 = (int) wxDateTime::Inv_Year ;
19064 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19065 bool result;
19066 PyObject * obj0 = 0 ;
19067 PyObject * obj1 = 0 ;
19068 char *kwnames[] = {
19069 (char *) "year",(char *) "cal", NULL
19070 };
19071
19072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19073 if (obj0) {
19074 {
19075 arg1 = (int)(SWIG_As_int(obj0));
19076 if (SWIG_arg_fail(1)) SWIG_fail;
19077 }
19078 }
19079 if (obj1) {
19080 {
19081 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19082 if (SWIG_arg_fail(2)) SWIG_fail;
19083 }
19084 }
19085 {
19086 PyThreadState* __tstate = wxPyBeginAllowThreads();
19087 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19088
19089 wxPyEndAllowThreads(__tstate);
19090 if (PyErr_Occurred()) SWIG_fail;
19091 }
19092 {
19093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19094 }
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj;
19103 int arg1 = (int) wxDateTime::Inv_Year ;
19104 int result;
19105 PyObject * obj0 = 0 ;
19106 char *kwnames[] = {
19107 (char *) "year", NULL
19108 };
19109
19110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19111 if (obj0) {
19112 {
19113 arg1 = (int)(SWIG_As_int(obj0));
19114 if (SWIG_arg_fail(1)) SWIG_fail;
19115 }
19116 }
19117 {
19118 PyThreadState* __tstate = wxPyBeginAllowThreads();
19119 result = (int)wxDateTime::GetCentury(arg1);
19120
19121 wxPyEndAllowThreads(__tstate);
19122 if (PyErr_Occurred()) SWIG_fail;
19123 }
19124 {
19125 resultobj = SWIG_From_int((int)(result));
19126 }
19127 return resultobj;
19128 fail:
19129 return NULL;
19130 }
19131
19132
19133 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19134 PyObject *resultobj;
19135 int arg1 ;
19136 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19137 int result;
19138 PyObject * obj0 = 0 ;
19139 PyObject * obj1 = 0 ;
19140 char *kwnames[] = {
19141 (char *) "year",(char *) "cal", NULL
19142 };
19143
19144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19145 {
19146 arg1 = (int)(SWIG_As_int(obj0));
19147 if (SWIG_arg_fail(1)) SWIG_fail;
19148 }
19149 if (obj1) {
19150 {
19151 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19152 if (SWIG_arg_fail(2)) SWIG_fail;
19153 }
19154 }
19155 {
19156 PyThreadState* __tstate = wxPyBeginAllowThreads();
19157 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19158
19159 wxPyEndAllowThreads(__tstate);
19160 if (PyErr_Occurred()) SWIG_fail;
19161 }
19162 {
19163 resultobj = SWIG_From_int((int)(result));
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 wxDateTime::Month arg1 ;
19174 int arg2 = (int) wxDateTime::Inv_Year ;
19175 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19176 int result;
19177 PyObject * obj0 = 0 ;
19178 PyObject * obj1 = 0 ;
19179 PyObject * obj2 = 0 ;
19180 char *kwnames[] = {
19181 (char *) "month",(char *) "year",(char *) "cal", NULL
19182 };
19183
19184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19185 {
19186 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19187 if (SWIG_arg_fail(1)) SWIG_fail;
19188 }
19189 if (obj1) {
19190 {
19191 arg2 = (int)(SWIG_As_int(obj1));
19192 if (SWIG_arg_fail(2)) SWIG_fail;
19193 }
19194 }
19195 if (obj2) {
19196 {
19197 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19198 if (SWIG_arg_fail(3)) SWIG_fail;
19199 }
19200 }
19201 {
19202 PyThreadState* __tstate = wxPyBeginAllowThreads();
19203 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19204
19205 wxPyEndAllowThreads(__tstate);
19206 if (PyErr_Occurred()) SWIG_fail;
19207 }
19208 {
19209 resultobj = SWIG_From_int((int)(result));
19210 }
19211 return resultobj;
19212 fail:
19213 return NULL;
19214 }
19215
19216
19217 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19218 PyObject *resultobj;
19219 wxDateTime::Month arg1 ;
19220 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19221 wxString result;
19222 PyObject * obj0 = 0 ;
19223 PyObject * obj1 = 0 ;
19224 char *kwnames[] = {
19225 (char *) "month",(char *) "flags", NULL
19226 };
19227
19228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19229 {
19230 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19231 if (SWIG_arg_fail(1)) SWIG_fail;
19232 }
19233 if (obj1) {
19234 {
19235 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19236 if (SWIG_arg_fail(2)) SWIG_fail;
19237 }
19238 }
19239 {
19240 PyThreadState* __tstate = wxPyBeginAllowThreads();
19241 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19242
19243 wxPyEndAllowThreads(__tstate);
19244 if (PyErr_Occurred()) SWIG_fail;
19245 }
19246 {
19247 #if wxUSE_UNICODE
19248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19249 #else
19250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19251 #endif
19252 }
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19260 PyObject *resultobj;
19261 wxDateTime::WeekDay arg1 ;
19262 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19263 wxString result;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char *kwnames[] = {
19267 (char *) "weekday",(char *) "flags", NULL
19268 };
19269
19270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19271 {
19272 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19273 if (SWIG_arg_fail(1)) SWIG_fail;
19274 }
19275 if (obj1) {
19276 {
19277 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19278 if (SWIG_arg_fail(2)) SWIG_fail;
19279 }
19280 }
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19284
19285 wxPyEndAllowThreads(__tstate);
19286 if (PyErr_Occurred()) SWIG_fail;
19287 }
19288 {
19289 #if wxUSE_UNICODE
19290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19291 #else
19292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19293 #endif
19294 }
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19302 PyObject *resultobj;
19303 wxString *arg1 = (wxString *) 0 ;
19304 wxString *arg2 = (wxString *) 0 ;
19305 bool temp1 = false ;
19306 bool temp2 = false ;
19307 PyObject * obj0 = 0 ;
19308 PyObject * obj1 = 0 ;
19309 char *kwnames[] = {
19310 (char *) "OUTPUT",(char *) "OUTPUT", NULL
19311 };
19312
19313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetAmPmStrings",kwnames,&obj0,&obj1)) goto fail;
19314 {
19315 arg1 = wxString_in_helper(obj0);
19316 if (arg1 == NULL) SWIG_fail;
19317 temp1 = true;
19318 }
19319 {
19320 arg2 = wxString_in_helper(obj1);
19321 if (arg2 == NULL) SWIG_fail;
19322 temp2 = true;
19323 }
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 wxDateTime::GetAmPmStrings(arg1,arg2);
19327
19328 wxPyEndAllowThreads(__tstate);
19329 if (PyErr_Occurred()) SWIG_fail;
19330 }
19331 Py_INCREF(Py_None); resultobj = Py_None;
19332 {
19333 if (temp1)
19334 delete arg1;
19335 }
19336 {
19337 if (temp2)
19338 delete arg2;
19339 }
19340 return resultobj;
19341 fail:
19342 {
19343 if (temp1)
19344 delete arg1;
19345 }
19346 {
19347 if (temp2)
19348 delete arg2;
19349 }
19350 return NULL;
19351 }
19352
19353
19354 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19355 PyObject *resultobj;
19356 int arg1 = (int) wxDateTime::Inv_Year ;
19357 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19358 bool result;
19359 PyObject * obj0 = 0 ;
19360 PyObject * obj1 = 0 ;
19361 char *kwnames[] = {
19362 (char *) "year",(char *) "country", NULL
19363 };
19364
19365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19366 if (obj0) {
19367 {
19368 arg1 = (int)(SWIG_As_int(obj0));
19369 if (SWIG_arg_fail(1)) SWIG_fail;
19370 }
19371 }
19372 if (obj1) {
19373 {
19374 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19375 if (SWIG_arg_fail(2)) SWIG_fail;
19376 }
19377 }
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19381
19382 wxPyEndAllowThreads(__tstate);
19383 if (PyErr_Occurred()) SWIG_fail;
19384 }
19385 {
19386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19387 }
19388 return resultobj;
19389 fail:
19390 return NULL;
19391 }
19392
19393
19394 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19395 PyObject *resultobj;
19396 int arg1 = (int) wxDateTime::Inv_Year ;
19397 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19398 wxDateTime result;
19399 PyObject * obj0 = 0 ;
19400 PyObject * obj1 = 0 ;
19401 char *kwnames[] = {
19402 (char *) "year",(char *) "country", NULL
19403 };
19404
19405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19406 if (obj0) {
19407 {
19408 arg1 = (int)(SWIG_As_int(obj0));
19409 if (SWIG_arg_fail(1)) SWIG_fail;
19410 }
19411 }
19412 if (obj1) {
19413 {
19414 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19415 if (SWIG_arg_fail(2)) SWIG_fail;
19416 }
19417 }
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19421
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 {
19426 wxDateTime * resultptr;
19427 resultptr = new wxDateTime((wxDateTime &)(result));
19428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19429 }
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj;
19438 int arg1 = (int) wxDateTime::Inv_Year ;
19439 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19440 wxDateTime result;
19441 PyObject * obj0 = 0 ;
19442 PyObject * obj1 = 0 ;
19443 char *kwnames[] = {
19444 (char *) "year",(char *) "country", NULL
19445 };
19446
19447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19448 if (obj0) {
19449 {
19450 arg1 = (int)(SWIG_As_int(obj0));
19451 if (SWIG_arg_fail(1)) SWIG_fail;
19452 }
19453 }
19454 if (obj1) {
19455 {
19456 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19457 if (SWIG_arg_fail(2)) SWIG_fail;
19458 }
19459 }
19460 {
19461 PyThreadState* __tstate = wxPyBeginAllowThreads();
19462 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19463
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 {
19468 wxDateTime * resultptr;
19469 resultptr = new wxDateTime((wxDateTime &)(result));
19470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19471 }
19472 return resultobj;
19473 fail:
19474 return NULL;
19475 }
19476
19477
19478 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19479 PyObject *resultobj;
19480 wxDateTime result;
19481 char *kwnames[] = {
19482 NULL
19483 };
19484
19485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19486 {
19487 PyThreadState* __tstate = wxPyBeginAllowThreads();
19488 result = wxDateTime::Now();
19489
19490 wxPyEndAllowThreads(__tstate);
19491 if (PyErr_Occurred()) SWIG_fail;
19492 }
19493 {
19494 wxDateTime * resultptr;
19495 resultptr = new wxDateTime((wxDateTime &)(result));
19496 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19497 }
19498 return resultobj;
19499 fail:
19500 return NULL;
19501 }
19502
19503
19504 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19505 PyObject *resultobj;
19506 wxDateTime result;
19507 char *kwnames[] = {
19508 NULL
19509 };
19510
19511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19512 {
19513 PyThreadState* __tstate = wxPyBeginAllowThreads();
19514 result = wxDateTime::UNow();
19515
19516 wxPyEndAllowThreads(__tstate);
19517 if (PyErr_Occurred()) SWIG_fail;
19518 }
19519 {
19520 wxDateTime * resultptr;
19521 resultptr = new wxDateTime((wxDateTime &)(result));
19522 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19523 }
19524 return resultobj;
19525 fail:
19526 return NULL;
19527 }
19528
19529
19530 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19531 PyObject *resultobj;
19532 wxDateTime result;
19533 char *kwnames[] = {
19534 NULL
19535 };
19536
19537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 result = wxDateTime::Today();
19541
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 {
19546 wxDateTime * resultptr;
19547 resultptr = new wxDateTime((wxDateTime &)(result));
19548 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19549 }
19550 return resultobj;
19551 fail:
19552 return NULL;
19553 }
19554
19555
19556 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19557 PyObject *resultobj;
19558 wxDateTime *result;
19559 char *kwnames[] = {
19560 NULL
19561 };
19562
19563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19564 {
19565 PyThreadState* __tstate = wxPyBeginAllowThreads();
19566 result = (wxDateTime *)new wxDateTime();
19567
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19572 return resultobj;
19573 fail:
19574 return NULL;
19575 }
19576
19577
19578 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19579 PyObject *resultobj;
19580 time_t arg1 ;
19581 wxDateTime *result;
19582 PyObject * obj0 = 0 ;
19583 char *kwnames[] = {
19584 (char *) "timet", NULL
19585 };
19586
19587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19588 {
19589 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19590 if (SWIG_arg_fail(1)) SWIG_fail;
19591 }
19592 {
19593 PyThreadState* __tstate = wxPyBeginAllowThreads();
19594 result = (wxDateTime *)new wxDateTime(arg1);
19595
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19607 PyObject *resultobj;
19608 double arg1 ;
19609 wxDateTime *result;
19610 PyObject * obj0 = 0 ;
19611 char *kwnames[] = {
19612 (char *) "jdn", NULL
19613 };
19614
19615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19616 {
19617 arg1 = (double)(SWIG_As_double(obj0));
19618 if (SWIG_arg_fail(1)) SWIG_fail;
19619 }
19620 {
19621 PyThreadState* __tstate = wxPyBeginAllowThreads();
19622 result = (wxDateTime *)new wxDateTime(arg1);
19623
19624 wxPyEndAllowThreads(__tstate);
19625 if (PyErr_Occurred()) SWIG_fail;
19626 }
19627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19628 return resultobj;
19629 fail:
19630 return NULL;
19631 }
19632
19633
19634 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19635 PyObject *resultobj;
19636 int arg1 ;
19637 int arg2 = (int) 0 ;
19638 int arg3 = (int) 0 ;
19639 int arg4 = (int) 0 ;
19640 wxDateTime *result;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 PyObject * obj2 = 0 ;
19644 PyObject * obj3 = 0 ;
19645 char *kwnames[] = {
19646 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19647 };
19648
19649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19650 {
19651 arg1 = (int)(SWIG_As_int(obj0));
19652 if (SWIG_arg_fail(1)) SWIG_fail;
19653 }
19654 if (obj1) {
19655 {
19656 arg2 = (int)(SWIG_As_int(obj1));
19657 if (SWIG_arg_fail(2)) SWIG_fail;
19658 }
19659 }
19660 if (obj2) {
19661 {
19662 arg3 = (int)(SWIG_As_int(obj2));
19663 if (SWIG_arg_fail(3)) SWIG_fail;
19664 }
19665 }
19666 if (obj3) {
19667 {
19668 arg4 = (int)(SWIG_As_int(obj3));
19669 if (SWIG_arg_fail(4)) SWIG_fail;
19670 }
19671 }
19672 {
19673 PyThreadState* __tstate = wxPyBeginAllowThreads();
19674 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19675
19676 wxPyEndAllowThreads(__tstate);
19677 if (PyErr_Occurred()) SWIG_fail;
19678 }
19679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19680 return resultobj;
19681 fail:
19682 return NULL;
19683 }
19684
19685
19686 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19687 PyObject *resultobj;
19688 int arg1 ;
19689 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19690 int arg3 = (int) wxDateTime::Inv_Year ;
19691 int arg4 = (int) 0 ;
19692 int arg5 = (int) 0 ;
19693 int arg6 = (int) 0 ;
19694 int arg7 = (int) 0 ;
19695 wxDateTime *result;
19696 PyObject * obj0 = 0 ;
19697 PyObject * obj1 = 0 ;
19698 PyObject * obj2 = 0 ;
19699 PyObject * obj3 = 0 ;
19700 PyObject * obj4 = 0 ;
19701 PyObject * obj5 = 0 ;
19702 PyObject * obj6 = 0 ;
19703 char *kwnames[] = {
19704 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19705 };
19706
19707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19708 {
19709 arg1 = (int)(SWIG_As_int(obj0));
19710 if (SWIG_arg_fail(1)) SWIG_fail;
19711 }
19712 if (obj1) {
19713 {
19714 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19715 if (SWIG_arg_fail(2)) SWIG_fail;
19716 }
19717 }
19718 if (obj2) {
19719 {
19720 arg3 = (int)(SWIG_As_int(obj2));
19721 if (SWIG_arg_fail(3)) SWIG_fail;
19722 }
19723 }
19724 if (obj3) {
19725 {
19726 arg4 = (int)(SWIG_As_int(obj3));
19727 if (SWIG_arg_fail(4)) SWIG_fail;
19728 }
19729 }
19730 if (obj4) {
19731 {
19732 arg5 = (int)(SWIG_As_int(obj4));
19733 if (SWIG_arg_fail(5)) SWIG_fail;
19734 }
19735 }
19736 if (obj5) {
19737 {
19738 arg6 = (int)(SWIG_As_int(obj5));
19739 if (SWIG_arg_fail(6)) SWIG_fail;
19740 }
19741 }
19742 if (obj6) {
19743 {
19744 arg7 = (int)(SWIG_As_int(obj6));
19745 if (SWIG_arg_fail(7)) SWIG_fail;
19746 }
19747 }
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19751
19752 wxPyEndAllowThreads(__tstate);
19753 if (PyErr_Occurred()) SWIG_fail;
19754 }
19755 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19756 return resultobj;
19757 fail:
19758 return NULL;
19759 }
19760
19761
19762 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19763 PyObject *resultobj;
19764 wxDateTime *arg1 = (wxDateTime *) 0 ;
19765 PyObject * obj0 = 0 ;
19766 char *kwnames[] = {
19767 (char *) "self", NULL
19768 };
19769
19770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19772 if (SWIG_arg_fail(1)) SWIG_fail;
19773 {
19774 PyThreadState* __tstate = wxPyBeginAllowThreads();
19775 delete arg1;
19776
19777 wxPyEndAllowThreads(__tstate);
19778 if (PyErr_Occurred()) SWIG_fail;
19779 }
19780 Py_INCREF(Py_None); resultobj = Py_None;
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj;
19789 wxDateTime *arg1 = (wxDateTime *) 0 ;
19790 wxDateTime *result;
19791 PyObject * obj0 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "self", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 {
19800 PyThreadState* __tstate = wxPyBeginAllowThreads();
19801 {
19802 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19803 result = (wxDateTime *) &_result_ref;
19804 }
19805
19806 wxPyEndAllowThreads(__tstate);
19807 if (PyErr_Occurred()) SWIG_fail;
19808 }
19809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj;
19818 wxDateTime *arg1 = (wxDateTime *) 0 ;
19819 time_t arg2 ;
19820 wxDateTime *result;
19821 PyObject * obj0 = 0 ;
19822 PyObject * obj1 = 0 ;
19823 char *kwnames[] = {
19824 (char *) "self",(char *) "timet", NULL
19825 };
19826
19827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19829 if (SWIG_arg_fail(1)) SWIG_fail;
19830 {
19831 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19832 if (SWIG_arg_fail(2)) SWIG_fail;
19833 }
19834 {
19835 PyThreadState* __tstate = wxPyBeginAllowThreads();
19836 {
19837 wxDateTime &_result_ref = (arg1)->Set(arg2);
19838 result = (wxDateTime *) &_result_ref;
19839 }
19840
19841 wxPyEndAllowThreads(__tstate);
19842 if (PyErr_Occurred()) SWIG_fail;
19843 }
19844 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19845 return resultobj;
19846 fail:
19847 return NULL;
19848 }
19849
19850
19851 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19852 PyObject *resultobj;
19853 wxDateTime *arg1 = (wxDateTime *) 0 ;
19854 double arg2 ;
19855 wxDateTime *result;
19856 PyObject * obj0 = 0 ;
19857 PyObject * obj1 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "self",(char *) "jdn", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 {
19866 arg2 = (double)(SWIG_As_double(obj1));
19867 if (SWIG_arg_fail(2)) SWIG_fail;
19868 }
19869 {
19870 PyThreadState* __tstate = wxPyBeginAllowThreads();
19871 {
19872 wxDateTime &_result_ref = (arg1)->Set(arg2);
19873 result = (wxDateTime *) &_result_ref;
19874 }
19875
19876 wxPyEndAllowThreads(__tstate);
19877 if (PyErr_Occurred()) SWIG_fail;
19878 }
19879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19880 return resultobj;
19881 fail:
19882 return NULL;
19883 }
19884
19885
19886 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19887 PyObject *resultobj;
19888 wxDateTime *arg1 = (wxDateTime *) 0 ;
19889 int arg2 ;
19890 int arg3 = (int) 0 ;
19891 int arg4 = (int) 0 ;
19892 int arg5 = (int) 0 ;
19893 wxDateTime *result;
19894 PyObject * obj0 = 0 ;
19895 PyObject * obj1 = 0 ;
19896 PyObject * obj2 = 0 ;
19897 PyObject * obj3 = 0 ;
19898 PyObject * obj4 = 0 ;
19899 char *kwnames[] = {
19900 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19901 };
19902
19903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19905 if (SWIG_arg_fail(1)) SWIG_fail;
19906 {
19907 arg2 = (int)(SWIG_As_int(obj1));
19908 if (SWIG_arg_fail(2)) SWIG_fail;
19909 }
19910 if (obj2) {
19911 {
19912 arg3 = (int)(SWIG_As_int(obj2));
19913 if (SWIG_arg_fail(3)) SWIG_fail;
19914 }
19915 }
19916 if (obj3) {
19917 {
19918 arg4 = (int)(SWIG_As_int(obj3));
19919 if (SWIG_arg_fail(4)) SWIG_fail;
19920 }
19921 }
19922 if (obj4) {
19923 {
19924 arg5 = (int)(SWIG_As_int(obj4));
19925 if (SWIG_arg_fail(5)) SWIG_fail;
19926 }
19927 }
19928 {
19929 PyThreadState* __tstate = wxPyBeginAllowThreads();
19930 {
19931 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19932 result = (wxDateTime *) &_result_ref;
19933 }
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj;
19947 wxDateTime *arg1 = (wxDateTime *) 0 ;
19948 int arg2 ;
19949 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19950 int arg4 = (int) wxDateTime::Inv_Year ;
19951 int arg5 = (int) 0 ;
19952 int arg6 = (int) 0 ;
19953 int arg7 = (int) 0 ;
19954 int arg8 = (int) 0 ;
19955 wxDateTime *result;
19956 PyObject * obj0 = 0 ;
19957 PyObject * obj1 = 0 ;
19958 PyObject * obj2 = 0 ;
19959 PyObject * obj3 = 0 ;
19960 PyObject * obj4 = 0 ;
19961 PyObject * obj5 = 0 ;
19962 PyObject * obj6 = 0 ;
19963 PyObject * obj7 = 0 ;
19964 char *kwnames[] = {
19965 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19966 };
19967
19968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19970 if (SWIG_arg_fail(1)) SWIG_fail;
19971 {
19972 arg2 = (int)(SWIG_As_int(obj1));
19973 if (SWIG_arg_fail(2)) SWIG_fail;
19974 }
19975 if (obj2) {
19976 {
19977 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
19978 if (SWIG_arg_fail(3)) SWIG_fail;
19979 }
19980 }
19981 if (obj3) {
19982 {
19983 arg4 = (int)(SWIG_As_int(obj3));
19984 if (SWIG_arg_fail(4)) SWIG_fail;
19985 }
19986 }
19987 if (obj4) {
19988 {
19989 arg5 = (int)(SWIG_As_int(obj4));
19990 if (SWIG_arg_fail(5)) SWIG_fail;
19991 }
19992 }
19993 if (obj5) {
19994 {
19995 arg6 = (int)(SWIG_As_int(obj5));
19996 if (SWIG_arg_fail(6)) SWIG_fail;
19997 }
19998 }
19999 if (obj6) {
20000 {
20001 arg7 = (int)(SWIG_As_int(obj6));
20002 if (SWIG_arg_fail(7)) SWIG_fail;
20003 }
20004 }
20005 if (obj7) {
20006 {
20007 arg8 = (int)(SWIG_As_int(obj7));
20008 if (SWIG_arg_fail(8)) SWIG_fail;
20009 }
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 {
20014 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
20015 result = (wxDateTime *) &_result_ref;
20016 }
20017
20018 wxPyEndAllowThreads(__tstate);
20019 if (PyErr_Occurred()) SWIG_fail;
20020 }
20021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20022 return resultobj;
20023 fail:
20024 return NULL;
20025 }
20026
20027
20028 static PyObject *_wrap_DateTime_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20029 PyObject *resultobj;
20030 wxDateTime *arg1 = (wxDateTime *) 0 ;
20031 wxDateTime *result;
20032 PyObject * obj0 = 0 ;
20033 char *kwnames[] = {
20034 (char *) "self", NULL
20035 };
20036
20037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20039 if (SWIG_arg_fail(1)) SWIG_fail;
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 {
20043 wxDateTime &_result_ref = (arg1)->ResetTime();
20044 result = (wxDateTime *) &_result_ref;
20045 }
20046
20047 wxPyEndAllowThreads(__tstate);
20048 if (PyErr_Occurred()) SWIG_fail;
20049 }
20050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20051 return resultobj;
20052 fail:
20053 return NULL;
20054 }
20055
20056
20057 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj;
20059 wxDateTime *arg1 = (wxDateTime *) 0 ;
20060 int arg2 ;
20061 wxDateTime *result;
20062 PyObject * obj0 = 0 ;
20063 PyObject * obj1 = 0 ;
20064 char *kwnames[] = {
20065 (char *) "self",(char *) "year", NULL
20066 };
20067
20068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20070 if (SWIG_arg_fail(1)) SWIG_fail;
20071 {
20072 arg2 = (int)(SWIG_As_int(obj1));
20073 if (SWIG_arg_fail(2)) SWIG_fail;
20074 }
20075 {
20076 PyThreadState* __tstate = wxPyBeginAllowThreads();
20077 {
20078 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20079 result = (wxDateTime *) &_result_ref;
20080 }
20081
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20093 PyObject *resultobj;
20094 wxDateTime *arg1 = (wxDateTime *) 0 ;
20095 wxDateTime::Month arg2 ;
20096 wxDateTime *result;
20097 PyObject * obj0 = 0 ;
20098 PyObject * obj1 = 0 ;
20099 char *kwnames[] = {
20100 (char *) "self",(char *) "month", NULL
20101 };
20102
20103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20105 if (SWIG_arg_fail(1)) SWIG_fail;
20106 {
20107 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20108 if (SWIG_arg_fail(2)) SWIG_fail;
20109 }
20110 {
20111 PyThreadState* __tstate = wxPyBeginAllowThreads();
20112 {
20113 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20114 result = (wxDateTime *) &_result_ref;
20115 }
20116
20117 wxPyEndAllowThreads(__tstate);
20118 if (PyErr_Occurred()) SWIG_fail;
20119 }
20120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20121 return resultobj;
20122 fail:
20123 return NULL;
20124 }
20125
20126
20127 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20128 PyObject *resultobj;
20129 wxDateTime *arg1 = (wxDateTime *) 0 ;
20130 int arg2 ;
20131 wxDateTime *result;
20132 PyObject * obj0 = 0 ;
20133 PyObject * obj1 = 0 ;
20134 char *kwnames[] = {
20135 (char *) "self",(char *) "day", NULL
20136 };
20137
20138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20140 if (SWIG_arg_fail(1)) SWIG_fail;
20141 {
20142 arg2 = (int)(SWIG_As_int(obj1));
20143 if (SWIG_arg_fail(2)) SWIG_fail;
20144 }
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 {
20148 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20149 result = (wxDateTime *) &_result_ref;
20150 }
20151
20152 wxPyEndAllowThreads(__tstate);
20153 if (PyErr_Occurred()) SWIG_fail;
20154 }
20155 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20163 PyObject *resultobj;
20164 wxDateTime *arg1 = (wxDateTime *) 0 ;
20165 int arg2 ;
20166 wxDateTime *result;
20167 PyObject * obj0 = 0 ;
20168 PyObject * obj1 = 0 ;
20169 char *kwnames[] = {
20170 (char *) "self",(char *) "hour", NULL
20171 };
20172
20173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20175 if (SWIG_arg_fail(1)) SWIG_fail;
20176 {
20177 arg2 = (int)(SWIG_As_int(obj1));
20178 if (SWIG_arg_fail(2)) SWIG_fail;
20179 }
20180 {
20181 PyThreadState* __tstate = wxPyBeginAllowThreads();
20182 {
20183 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20184 result = (wxDateTime *) &_result_ref;
20185 }
20186
20187 wxPyEndAllowThreads(__tstate);
20188 if (PyErr_Occurred()) SWIG_fail;
20189 }
20190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20191 return resultobj;
20192 fail:
20193 return NULL;
20194 }
20195
20196
20197 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20198 PyObject *resultobj;
20199 wxDateTime *arg1 = (wxDateTime *) 0 ;
20200 int arg2 ;
20201 wxDateTime *result;
20202 PyObject * obj0 = 0 ;
20203 PyObject * obj1 = 0 ;
20204 char *kwnames[] = {
20205 (char *) "self",(char *) "minute", NULL
20206 };
20207
20208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20210 if (SWIG_arg_fail(1)) SWIG_fail;
20211 {
20212 arg2 = (int)(SWIG_As_int(obj1));
20213 if (SWIG_arg_fail(2)) SWIG_fail;
20214 }
20215 {
20216 PyThreadState* __tstate = wxPyBeginAllowThreads();
20217 {
20218 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20219 result = (wxDateTime *) &_result_ref;
20220 }
20221
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj;
20234 wxDateTime *arg1 = (wxDateTime *) 0 ;
20235 int arg2 ;
20236 wxDateTime *result;
20237 PyObject * obj0 = 0 ;
20238 PyObject * obj1 = 0 ;
20239 char *kwnames[] = {
20240 (char *) "self",(char *) "second", NULL
20241 };
20242
20243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20245 if (SWIG_arg_fail(1)) SWIG_fail;
20246 {
20247 arg2 = (int)(SWIG_As_int(obj1));
20248 if (SWIG_arg_fail(2)) SWIG_fail;
20249 }
20250 {
20251 PyThreadState* __tstate = wxPyBeginAllowThreads();
20252 {
20253 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20254 result = (wxDateTime *) &_result_ref;
20255 }
20256
20257 wxPyEndAllowThreads(__tstate);
20258 if (PyErr_Occurred()) SWIG_fail;
20259 }
20260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20268 PyObject *resultobj;
20269 wxDateTime *arg1 = (wxDateTime *) 0 ;
20270 int arg2 ;
20271 wxDateTime *result;
20272 PyObject * obj0 = 0 ;
20273 PyObject * obj1 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "self",(char *) "millisecond", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20280 if (SWIG_arg_fail(1)) SWIG_fail;
20281 {
20282 arg2 = (int)(SWIG_As_int(obj1));
20283 if (SWIG_arg_fail(2)) SWIG_fail;
20284 }
20285 {
20286 PyThreadState* __tstate = wxPyBeginAllowThreads();
20287 {
20288 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20289 result = (wxDateTime *) &_result_ref;
20290 }
20291
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj;
20304 wxDateTime *arg1 = (wxDateTime *) 0 ;
20305 wxDateTime::WeekDay arg2 ;
20306 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20307 wxDateTime *result;
20308 PyObject * obj0 = 0 ;
20309 PyObject * obj1 = 0 ;
20310 PyObject * obj2 = 0 ;
20311 char *kwnames[] = {
20312 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20313 };
20314
20315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20317 if (SWIG_arg_fail(1)) SWIG_fail;
20318 {
20319 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20320 if (SWIG_arg_fail(2)) SWIG_fail;
20321 }
20322 if (obj2) {
20323 {
20324 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20325 if (SWIG_arg_fail(3)) SWIG_fail;
20326 }
20327 }
20328 {
20329 PyThreadState* __tstate = wxPyBeginAllowThreads();
20330 {
20331 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20332 result = (wxDateTime *) &_result_ref;
20333 }
20334
20335 wxPyEndAllowThreads(__tstate);
20336 if (PyErr_Occurred()) SWIG_fail;
20337 }
20338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj;
20347 wxDateTime *arg1 = (wxDateTime *) 0 ;
20348 wxDateTime::WeekDay arg2 ;
20349 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20350 wxDateTime result;
20351 PyObject * obj0 = 0 ;
20352 PyObject * obj1 = 0 ;
20353 PyObject * obj2 = 0 ;
20354 char *kwnames[] = {
20355 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20356 };
20357
20358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20360 if (SWIG_arg_fail(1)) SWIG_fail;
20361 {
20362 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20363 if (SWIG_arg_fail(2)) SWIG_fail;
20364 }
20365 if (obj2) {
20366 {
20367 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20368 if (SWIG_arg_fail(3)) SWIG_fail;
20369 }
20370 }
20371 {
20372 PyThreadState* __tstate = wxPyBeginAllowThreads();
20373 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20374
20375 wxPyEndAllowThreads(__tstate);
20376 if (PyErr_Occurred()) SWIG_fail;
20377 }
20378 {
20379 wxDateTime * resultptr;
20380 resultptr = new wxDateTime((wxDateTime &)(result));
20381 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj;
20391 wxDateTime *arg1 = (wxDateTime *) 0 ;
20392 wxDateTime::WeekDay arg2 ;
20393 wxDateTime *result;
20394 PyObject * obj0 = 0 ;
20395 PyObject * obj1 = 0 ;
20396 char *kwnames[] = {
20397 (char *) "self",(char *) "weekday", NULL
20398 };
20399
20400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20402 if (SWIG_arg_fail(1)) SWIG_fail;
20403 {
20404 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20405 if (SWIG_arg_fail(2)) SWIG_fail;
20406 }
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 {
20410 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20411 result = (wxDateTime *) &_result_ref;
20412 }
20413
20414 wxPyEndAllowThreads(__tstate);
20415 if (PyErr_Occurred()) SWIG_fail;
20416 }
20417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20418 return resultobj;
20419 fail:
20420 return NULL;
20421 }
20422
20423
20424 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20425 PyObject *resultobj;
20426 wxDateTime *arg1 = (wxDateTime *) 0 ;
20427 wxDateTime::WeekDay arg2 ;
20428 wxDateTime result;
20429 PyObject * obj0 = 0 ;
20430 PyObject * obj1 = 0 ;
20431 char *kwnames[] = {
20432 (char *) "self",(char *) "weekday", NULL
20433 };
20434
20435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20437 if (SWIG_arg_fail(1)) SWIG_fail;
20438 {
20439 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20440 if (SWIG_arg_fail(2)) SWIG_fail;
20441 }
20442 {
20443 PyThreadState* __tstate = wxPyBeginAllowThreads();
20444 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20445
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 {
20450 wxDateTime * resultptr;
20451 resultptr = new wxDateTime((wxDateTime &)(result));
20452 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20453 }
20454 return resultobj;
20455 fail:
20456 return NULL;
20457 }
20458
20459
20460 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20461 PyObject *resultobj;
20462 wxDateTime *arg1 = (wxDateTime *) 0 ;
20463 wxDateTime::WeekDay arg2 ;
20464 wxDateTime *result;
20465 PyObject * obj0 = 0 ;
20466 PyObject * obj1 = 0 ;
20467 char *kwnames[] = {
20468 (char *) "self",(char *) "weekday", NULL
20469 };
20470
20471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20473 if (SWIG_arg_fail(1)) SWIG_fail;
20474 {
20475 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20476 if (SWIG_arg_fail(2)) SWIG_fail;
20477 }
20478 {
20479 PyThreadState* __tstate = wxPyBeginAllowThreads();
20480 {
20481 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20482 result = (wxDateTime *) &_result_ref;
20483 }
20484
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20489 return resultobj;
20490 fail:
20491 return NULL;
20492 }
20493
20494
20495 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20496 PyObject *resultobj;
20497 wxDateTime *arg1 = (wxDateTime *) 0 ;
20498 wxDateTime::WeekDay arg2 ;
20499 wxDateTime result;
20500 PyObject * obj0 = 0 ;
20501 PyObject * obj1 = 0 ;
20502 char *kwnames[] = {
20503 (char *) "self",(char *) "weekday", NULL
20504 };
20505
20506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20508 if (SWIG_arg_fail(1)) SWIG_fail;
20509 {
20510 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20511 if (SWIG_arg_fail(2)) SWIG_fail;
20512 }
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20516
20517 wxPyEndAllowThreads(__tstate);
20518 if (PyErr_Occurred()) SWIG_fail;
20519 }
20520 {
20521 wxDateTime * resultptr;
20522 resultptr = new wxDateTime((wxDateTime &)(result));
20523 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20524 }
20525 return resultobj;
20526 fail:
20527 return NULL;
20528 }
20529
20530
20531 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20532 PyObject *resultobj;
20533 wxDateTime *arg1 = (wxDateTime *) 0 ;
20534 wxDateTime::WeekDay arg2 ;
20535 int arg3 = (int) 1 ;
20536 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20537 int arg5 = (int) wxDateTime::Inv_Year ;
20538 bool result;
20539 PyObject * obj0 = 0 ;
20540 PyObject * obj1 = 0 ;
20541 PyObject * obj2 = 0 ;
20542 PyObject * obj3 = 0 ;
20543 PyObject * obj4 = 0 ;
20544 char *kwnames[] = {
20545 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20546 };
20547
20548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20550 if (SWIG_arg_fail(1)) SWIG_fail;
20551 {
20552 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20553 if (SWIG_arg_fail(2)) SWIG_fail;
20554 }
20555 if (obj2) {
20556 {
20557 arg3 = (int)(SWIG_As_int(obj2));
20558 if (SWIG_arg_fail(3)) SWIG_fail;
20559 }
20560 }
20561 if (obj3) {
20562 {
20563 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20564 if (SWIG_arg_fail(4)) SWIG_fail;
20565 }
20566 }
20567 if (obj4) {
20568 {
20569 arg5 = (int)(SWIG_As_int(obj4));
20570 if (SWIG_arg_fail(5)) SWIG_fail;
20571 }
20572 }
20573 {
20574 PyThreadState* __tstate = wxPyBeginAllowThreads();
20575 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20576
20577 wxPyEndAllowThreads(__tstate);
20578 if (PyErr_Occurred()) SWIG_fail;
20579 }
20580 {
20581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20582 }
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20590 PyObject *resultobj;
20591 wxDateTime *arg1 = (wxDateTime *) 0 ;
20592 wxDateTime::WeekDay arg2 ;
20593 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20594 int arg4 = (int) wxDateTime::Inv_Year ;
20595 bool result;
20596 PyObject * obj0 = 0 ;
20597 PyObject * obj1 = 0 ;
20598 PyObject * obj2 = 0 ;
20599 PyObject * obj3 = 0 ;
20600 char *kwnames[] = {
20601 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20602 };
20603
20604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20606 if (SWIG_arg_fail(1)) SWIG_fail;
20607 {
20608 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20609 if (SWIG_arg_fail(2)) SWIG_fail;
20610 }
20611 if (obj2) {
20612 {
20613 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20614 if (SWIG_arg_fail(3)) SWIG_fail;
20615 }
20616 }
20617 if (obj3) {
20618 {
20619 arg4 = (int)(SWIG_As_int(obj3));
20620 if (SWIG_arg_fail(4)) SWIG_fail;
20621 }
20622 }
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20626
20627 wxPyEndAllowThreads(__tstate);
20628 if (PyErr_Occurred()) SWIG_fail;
20629 }
20630 {
20631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20632 }
20633 return resultobj;
20634 fail:
20635 return NULL;
20636 }
20637
20638
20639 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20640 PyObject *resultobj;
20641 wxDateTime *arg1 = (wxDateTime *) 0 ;
20642 wxDateTime::WeekDay arg2 ;
20643 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20644 int arg4 = (int) wxDateTime::Inv_Year ;
20645 wxDateTime result;
20646 PyObject * obj0 = 0 ;
20647 PyObject * obj1 = 0 ;
20648 PyObject * obj2 = 0 ;
20649 PyObject * obj3 = 0 ;
20650 char *kwnames[] = {
20651 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20652 };
20653
20654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20656 if (SWIG_arg_fail(1)) SWIG_fail;
20657 {
20658 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20659 if (SWIG_arg_fail(2)) SWIG_fail;
20660 }
20661 if (obj2) {
20662 {
20663 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20664 if (SWIG_arg_fail(3)) SWIG_fail;
20665 }
20666 }
20667 if (obj3) {
20668 {
20669 arg4 = (int)(SWIG_As_int(obj3));
20670 if (SWIG_arg_fail(4)) SWIG_fail;
20671 }
20672 }
20673 {
20674 PyThreadState* __tstate = wxPyBeginAllowThreads();
20675 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20676
20677 wxPyEndAllowThreads(__tstate);
20678 if (PyErr_Occurred()) SWIG_fail;
20679 }
20680 {
20681 wxDateTime * resultptr;
20682 resultptr = new wxDateTime((wxDateTime &)(result));
20683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20684 }
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20692 PyObject *resultobj;
20693 wxDateTime *arg1 = (wxDateTime *) 0 ;
20694 int arg2 ;
20695 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20696 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20697 bool result;
20698 PyObject * obj0 = 0 ;
20699 PyObject * obj1 = 0 ;
20700 PyObject * obj2 = 0 ;
20701 PyObject * obj3 = 0 ;
20702 char *kwnames[] = {
20703 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20704 };
20705
20706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20708 if (SWIG_arg_fail(1)) SWIG_fail;
20709 {
20710 arg2 = (int)(SWIG_As_int(obj1));
20711 if (SWIG_arg_fail(2)) SWIG_fail;
20712 }
20713 if (obj2) {
20714 {
20715 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20716 if (SWIG_arg_fail(3)) SWIG_fail;
20717 }
20718 }
20719 if (obj3) {
20720 {
20721 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20722 if (SWIG_arg_fail(4)) SWIG_fail;
20723 }
20724 }
20725 {
20726 PyThreadState* __tstate = wxPyBeginAllowThreads();
20727 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20728
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 {
20733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20734 }
20735 return resultobj;
20736 fail:
20737 return NULL;
20738 }
20739
20740
20741 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20742 PyObject *resultobj;
20743 wxDateTime *arg1 = (wxDateTime *) 0 ;
20744 int arg2 ;
20745 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20746 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20747 wxDateTime result;
20748 PyObject * obj0 = 0 ;
20749 PyObject * obj1 = 0 ;
20750 PyObject * obj2 = 0 ;
20751 PyObject * obj3 = 0 ;
20752 char *kwnames[] = {
20753 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20754 };
20755
20756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20758 if (SWIG_arg_fail(1)) SWIG_fail;
20759 {
20760 arg2 = (int)(SWIG_As_int(obj1));
20761 if (SWIG_arg_fail(2)) SWIG_fail;
20762 }
20763 if (obj2) {
20764 {
20765 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20766 if (SWIG_arg_fail(3)) SWIG_fail;
20767 }
20768 }
20769 if (obj3) {
20770 {
20771 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20772 if (SWIG_arg_fail(4)) SWIG_fail;
20773 }
20774 }
20775 {
20776 PyThreadState* __tstate = wxPyBeginAllowThreads();
20777 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20778
20779 wxPyEndAllowThreads(__tstate);
20780 if (PyErr_Occurred()) SWIG_fail;
20781 }
20782 {
20783 wxDateTime * resultptr;
20784 resultptr = new wxDateTime((wxDateTime &)(result));
20785 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20786 }
20787 return resultobj;
20788 fail:
20789 return NULL;
20790 }
20791
20792
20793 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20794 PyObject *resultobj;
20795 int arg1 ;
20796 int arg2 ;
20797 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20798 wxDateTime result;
20799 PyObject * obj0 = 0 ;
20800 PyObject * obj1 = 0 ;
20801 PyObject * obj2 = 0 ;
20802 char *kwnames[] = {
20803 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20804 };
20805
20806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20807 {
20808 arg1 = (int)(SWIG_As_int(obj0));
20809 if (SWIG_arg_fail(1)) SWIG_fail;
20810 }
20811 {
20812 arg2 = (int)(SWIG_As_int(obj1));
20813 if (SWIG_arg_fail(2)) SWIG_fail;
20814 }
20815 if (obj2) {
20816 {
20817 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20818 if (SWIG_arg_fail(3)) SWIG_fail;
20819 }
20820 }
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 {
20829 wxDateTime * resultptr;
20830 resultptr = new wxDateTime((wxDateTime &)(result));
20831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20832 }
20833 return resultobj;
20834 fail:
20835 return NULL;
20836 }
20837
20838
20839 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20840 PyObject *resultobj;
20841 wxDateTime *arg1 = (wxDateTime *) 0 ;
20842 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20843 int arg3 = (int) wxDateTime::Inv_Year ;
20844 wxDateTime *result;
20845 PyObject * obj0 = 0 ;
20846 PyObject * obj1 = 0 ;
20847 PyObject * obj2 = 0 ;
20848 char *kwnames[] = {
20849 (char *) "self",(char *) "month",(char *) "year", NULL
20850 };
20851
20852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20854 if (SWIG_arg_fail(1)) SWIG_fail;
20855 if (obj1) {
20856 {
20857 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20858 if (SWIG_arg_fail(2)) SWIG_fail;
20859 }
20860 }
20861 if (obj2) {
20862 {
20863 arg3 = (int)(SWIG_As_int(obj2));
20864 if (SWIG_arg_fail(3)) SWIG_fail;
20865 }
20866 }
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 {
20870 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20871 result = (wxDateTime *) &_result_ref;
20872 }
20873
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20885 PyObject *resultobj;
20886 wxDateTime *arg1 = (wxDateTime *) 0 ;
20887 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20888 int arg3 = (int) wxDateTime::Inv_Year ;
20889 wxDateTime result;
20890 PyObject * obj0 = 0 ;
20891 PyObject * obj1 = 0 ;
20892 PyObject * obj2 = 0 ;
20893 char *kwnames[] = {
20894 (char *) "self",(char *) "month",(char *) "year", NULL
20895 };
20896
20897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20899 if (SWIG_arg_fail(1)) SWIG_fail;
20900 if (obj1) {
20901 {
20902 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20903 if (SWIG_arg_fail(2)) SWIG_fail;
20904 }
20905 }
20906 if (obj2) {
20907 {
20908 arg3 = (int)(SWIG_As_int(obj2));
20909 if (SWIG_arg_fail(3)) SWIG_fail;
20910 }
20911 }
20912 {
20913 PyThreadState* __tstate = wxPyBeginAllowThreads();
20914 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20915
20916 wxPyEndAllowThreads(__tstate);
20917 if (PyErr_Occurred()) SWIG_fail;
20918 }
20919 {
20920 wxDateTime * resultptr;
20921 resultptr = new wxDateTime((wxDateTime &)(result));
20922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20923 }
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj;
20932 wxDateTime *arg1 = (wxDateTime *) 0 ;
20933 int arg2 ;
20934 wxDateTime *result;
20935 PyObject * obj0 = 0 ;
20936 PyObject * obj1 = 0 ;
20937 char *kwnames[] = {
20938 (char *) "self",(char *) "yday", NULL
20939 };
20940
20941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20943 if (SWIG_arg_fail(1)) SWIG_fail;
20944 {
20945 arg2 = (int)(SWIG_As_int(obj1));
20946 if (SWIG_arg_fail(2)) SWIG_fail;
20947 }
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 {
20951 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20952 result = (wxDateTime *) &_result_ref;
20953 }
20954
20955 wxPyEndAllowThreads(__tstate);
20956 if (PyErr_Occurred()) SWIG_fail;
20957 }
20958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20959 return resultobj;
20960 fail:
20961 return NULL;
20962 }
20963
20964
20965 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20966 PyObject *resultobj;
20967 wxDateTime *arg1 = (wxDateTime *) 0 ;
20968 int arg2 ;
20969 wxDateTime result;
20970 PyObject * obj0 = 0 ;
20971 PyObject * obj1 = 0 ;
20972 char *kwnames[] = {
20973 (char *) "self",(char *) "yday", NULL
20974 };
20975
20976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
20977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20978 if (SWIG_arg_fail(1)) SWIG_fail;
20979 {
20980 arg2 = (int)(SWIG_As_int(obj1));
20981 if (SWIG_arg_fail(2)) SWIG_fail;
20982 }
20983 {
20984 PyThreadState* __tstate = wxPyBeginAllowThreads();
20985 result = (arg1)->GetYearDay(arg2);
20986
20987 wxPyEndAllowThreads(__tstate);
20988 if (PyErr_Occurred()) SWIG_fail;
20989 }
20990 {
20991 wxDateTime * resultptr;
20992 resultptr = new wxDateTime((wxDateTime &)(result));
20993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20994 }
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj;
21003 wxDateTime *arg1 = (wxDateTime *) 0 ;
21004 double result;
21005 PyObject * obj0 = 0 ;
21006 char *kwnames[] = {
21007 (char *) "self", NULL
21008 };
21009
21010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21012 if (SWIG_arg_fail(1)) SWIG_fail;
21013 {
21014 PyThreadState* __tstate = wxPyBeginAllowThreads();
21015 result = (double)(arg1)->GetJulianDayNumber();
21016
21017 wxPyEndAllowThreads(__tstate);
21018 if (PyErr_Occurred()) SWIG_fail;
21019 }
21020 {
21021 resultobj = SWIG_From_double((double)(result));
21022 }
21023 return resultobj;
21024 fail:
21025 return NULL;
21026 }
21027
21028
21029 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21030 PyObject *resultobj;
21031 wxDateTime *arg1 = (wxDateTime *) 0 ;
21032 double result;
21033 PyObject * obj0 = 0 ;
21034 char *kwnames[] = {
21035 (char *) "self", NULL
21036 };
21037
21038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21040 if (SWIG_arg_fail(1)) SWIG_fail;
21041 {
21042 PyThreadState* __tstate = wxPyBeginAllowThreads();
21043 result = (double)(arg1)->GetJDN();
21044
21045 wxPyEndAllowThreads(__tstate);
21046 if (PyErr_Occurred()) SWIG_fail;
21047 }
21048 {
21049 resultobj = SWIG_From_double((double)(result));
21050 }
21051 return resultobj;
21052 fail:
21053 return NULL;
21054 }
21055
21056
21057 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21058 PyObject *resultobj;
21059 wxDateTime *arg1 = (wxDateTime *) 0 ;
21060 double result;
21061 PyObject * obj0 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "self", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21068 if (SWIG_arg_fail(1)) SWIG_fail;
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21072
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 {
21077 resultobj = SWIG_From_double((double)(result));
21078 }
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj;
21087 wxDateTime *arg1 = (wxDateTime *) 0 ;
21088 double result;
21089 PyObject * obj0 = 0 ;
21090 char *kwnames[] = {
21091 (char *) "self", NULL
21092 };
21093
21094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21096 if (SWIG_arg_fail(1)) SWIG_fail;
21097 {
21098 PyThreadState* __tstate = wxPyBeginAllowThreads();
21099 result = (double)(arg1)->GetMJD();
21100
21101 wxPyEndAllowThreads(__tstate);
21102 if (PyErr_Occurred()) SWIG_fail;
21103 }
21104 {
21105 resultobj = SWIG_From_double((double)(result));
21106 }
21107 return resultobj;
21108 fail:
21109 return NULL;
21110 }
21111
21112
21113 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21114 PyObject *resultobj;
21115 wxDateTime *arg1 = (wxDateTime *) 0 ;
21116 double result;
21117 PyObject * obj0 = 0 ;
21118 char *kwnames[] = {
21119 (char *) "self", NULL
21120 };
21121
21122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21124 if (SWIG_arg_fail(1)) SWIG_fail;
21125 {
21126 PyThreadState* __tstate = wxPyBeginAllowThreads();
21127 result = (double)(arg1)->GetRataDie();
21128
21129 wxPyEndAllowThreads(__tstate);
21130 if (PyErr_Occurred()) SWIG_fail;
21131 }
21132 {
21133 resultobj = SWIG_From_double((double)(result));
21134 }
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21142 PyObject *resultobj;
21143 wxDateTime *arg1 = (wxDateTime *) 0 ;
21144 wxDateTime::TimeZone *arg2 = 0 ;
21145 bool arg3 = (bool) false ;
21146 wxDateTime result;
21147 bool temp2 = false ;
21148 PyObject * obj0 = 0 ;
21149 PyObject * obj1 = 0 ;
21150 PyObject * obj2 = 0 ;
21151 char *kwnames[] = {
21152 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21153 };
21154
21155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21157 if (SWIG_arg_fail(1)) SWIG_fail;
21158 {
21159 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21160 temp2 = true;
21161 }
21162 if (obj2) {
21163 {
21164 arg3 = (bool)(SWIG_As_bool(obj2));
21165 if (SWIG_arg_fail(3)) SWIG_fail;
21166 }
21167 }
21168 {
21169 PyThreadState* __tstate = wxPyBeginAllowThreads();
21170 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21171
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 {
21176 wxDateTime * resultptr;
21177 resultptr = new wxDateTime((wxDateTime &)(result));
21178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21179 }
21180 {
21181 if (temp2) delete arg2;
21182 }
21183 return resultobj;
21184 fail:
21185 {
21186 if (temp2) delete arg2;
21187 }
21188 return NULL;
21189 }
21190
21191
21192 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21193 PyObject *resultobj;
21194 wxDateTime *arg1 = (wxDateTime *) 0 ;
21195 wxDateTime::TimeZone *arg2 = 0 ;
21196 bool arg3 = (bool) false ;
21197 wxDateTime *result;
21198 bool temp2 = false ;
21199 PyObject * obj0 = 0 ;
21200 PyObject * obj1 = 0 ;
21201 PyObject * obj2 = 0 ;
21202 char *kwnames[] = {
21203 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21204 };
21205
21206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21208 if (SWIG_arg_fail(1)) SWIG_fail;
21209 {
21210 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21211 temp2 = true;
21212 }
21213 if (obj2) {
21214 {
21215 arg3 = (bool)(SWIG_As_bool(obj2));
21216 if (SWIG_arg_fail(3)) SWIG_fail;
21217 }
21218 }
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 {
21222 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21223 result = (wxDateTime *) &_result_ref;
21224 }
21225
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21230 {
21231 if (temp2) delete arg2;
21232 }
21233 return resultobj;
21234 fail:
21235 {
21236 if (temp2) delete arg2;
21237 }
21238 return NULL;
21239 }
21240
21241
21242 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21243 PyObject *resultobj;
21244 wxDateTime *arg1 = (wxDateTime *) 0 ;
21245 bool arg2 = (bool) false ;
21246 wxDateTime result;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char *kwnames[] = {
21250 (char *) "self",(char *) "noDST", NULL
21251 };
21252
21253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21255 if (SWIG_arg_fail(1)) SWIG_fail;
21256 if (obj1) {
21257 {
21258 arg2 = (bool)(SWIG_As_bool(obj1));
21259 if (SWIG_arg_fail(2)) SWIG_fail;
21260 }
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (arg1)->ToGMT(arg2);
21265
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 {
21270 wxDateTime * resultptr;
21271 resultptr = new wxDateTime((wxDateTime &)(result));
21272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21273 }
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21281 PyObject *resultobj;
21282 wxDateTime *arg1 = (wxDateTime *) 0 ;
21283 bool arg2 = (bool) false ;
21284 wxDateTime *result;
21285 PyObject * obj0 = 0 ;
21286 PyObject * obj1 = 0 ;
21287 char *kwnames[] = {
21288 (char *) "self",(char *) "noDST", NULL
21289 };
21290
21291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21293 if (SWIG_arg_fail(1)) SWIG_fail;
21294 if (obj1) {
21295 {
21296 arg2 = (bool)(SWIG_As_bool(obj1));
21297 if (SWIG_arg_fail(2)) SWIG_fail;
21298 }
21299 }
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 {
21303 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21304 result = (wxDateTime *) &_result_ref;
21305 }
21306
21307 wxPyEndAllowThreads(__tstate);
21308 if (PyErr_Occurred()) SWIG_fail;
21309 }
21310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21311 return resultobj;
21312 fail:
21313 return NULL;
21314 }
21315
21316
21317 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21318 PyObject *resultobj;
21319 wxDateTime *arg1 = (wxDateTime *) 0 ;
21320 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21321 int result;
21322 PyObject * obj0 = 0 ;
21323 PyObject * obj1 = 0 ;
21324 char *kwnames[] = {
21325 (char *) "self",(char *) "country", NULL
21326 };
21327
21328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21330 if (SWIG_arg_fail(1)) SWIG_fail;
21331 if (obj1) {
21332 {
21333 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21334 if (SWIG_arg_fail(2)) SWIG_fail;
21335 }
21336 }
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21340
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 {
21345 resultobj = SWIG_From_int((int)(result));
21346 }
21347 return resultobj;
21348 fail:
21349 return NULL;
21350 }
21351
21352
21353 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxDateTime *arg1 = (wxDateTime *) 0 ;
21356 bool result;
21357 PyObject * obj0 = 0 ;
21358 char *kwnames[] = {
21359 (char *) "self", NULL
21360 };
21361
21362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21364 if (SWIG_arg_fail(1)) SWIG_fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 result = (bool)((wxDateTime const *)arg1)->IsValid();
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 {
21373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21374 }
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj;
21383 wxDateTime *arg1 = (wxDateTime *) 0 ;
21384 time_t result;
21385 PyObject * obj0 = 0 ;
21386 char *kwnames[] = {
21387 (char *) "self", NULL
21388 };
21389
21390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21392 if (SWIG_arg_fail(1)) SWIG_fail;
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21396
21397 wxPyEndAllowThreads(__tstate);
21398 if (PyErr_Occurred()) SWIG_fail;
21399 }
21400 {
21401 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21402 }
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj;
21411 wxDateTime *arg1 = (wxDateTime *) 0 ;
21412 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21413 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21414 int result;
21415 bool temp2 = false ;
21416 PyObject * obj0 = 0 ;
21417 PyObject * obj1 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self",(char *) "tz", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 if (obj1) {
21426 {
21427 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21428 temp2 = true;
21429 }
21430 }
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 {
21439 resultobj = SWIG_From_int((int)(result));
21440 }
21441 {
21442 if (temp2) delete arg2;
21443 }
21444 return resultobj;
21445 fail:
21446 {
21447 if (temp2) delete arg2;
21448 }
21449 return NULL;
21450 }
21451
21452
21453 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21454 PyObject *resultobj;
21455 wxDateTime *arg1 = (wxDateTime *) 0 ;
21456 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21457 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21458 wxDateTime::Month result;
21459 bool temp2 = false ;
21460 PyObject * obj0 = 0 ;
21461 PyObject * obj1 = 0 ;
21462 char *kwnames[] = {
21463 (char *) "self",(char *) "tz", NULL
21464 };
21465
21466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21468 if (SWIG_arg_fail(1)) SWIG_fail;
21469 if (obj1) {
21470 {
21471 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21472 temp2 = true;
21473 }
21474 }
21475 {
21476 PyThreadState* __tstate = wxPyBeginAllowThreads();
21477 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21478
21479 wxPyEndAllowThreads(__tstate);
21480 if (PyErr_Occurred()) SWIG_fail;
21481 }
21482 resultobj = SWIG_From_int((result));
21483 {
21484 if (temp2) delete arg2;
21485 }
21486 return resultobj;
21487 fail:
21488 {
21489 if (temp2) delete arg2;
21490 }
21491 return NULL;
21492 }
21493
21494
21495 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21496 PyObject *resultobj;
21497 wxDateTime *arg1 = (wxDateTime *) 0 ;
21498 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21499 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21500 int result;
21501 bool temp2 = false ;
21502 PyObject * obj0 = 0 ;
21503 PyObject * obj1 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self",(char *) "tz", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 if (obj1) {
21512 {
21513 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21514 temp2 = true;
21515 }
21516 }
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21520
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 {
21525 resultobj = SWIG_From_int((int)(result));
21526 }
21527 {
21528 if (temp2) delete arg2;
21529 }
21530 return resultobj;
21531 fail:
21532 {
21533 if (temp2) delete arg2;
21534 }
21535 return NULL;
21536 }
21537
21538
21539 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21540 PyObject *resultobj;
21541 wxDateTime *arg1 = (wxDateTime *) 0 ;
21542 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21543 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21544 wxDateTime::WeekDay result;
21545 bool temp2 = false ;
21546 PyObject * obj0 = 0 ;
21547 PyObject * obj1 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "self",(char *) "tz", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21554 if (SWIG_arg_fail(1)) SWIG_fail;
21555 if (obj1) {
21556 {
21557 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21558 temp2 = true;
21559 }
21560 }
21561 {
21562 PyThreadState* __tstate = wxPyBeginAllowThreads();
21563 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21564
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 resultobj = SWIG_From_int((result));
21569 {
21570 if (temp2) delete arg2;
21571 }
21572 return resultobj;
21573 fail:
21574 {
21575 if (temp2) delete arg2;
21576 }
21577 return NULL;
21578 }
21579
21580
21581 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21582 PyObject *resultobj;
21583 wxDateTime *arg1 = (wxDateTime *) 0 ;
21584 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21585 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21586 int result;
21587 bool temp2 = false ;
21588 PyObject * obj0 = 0 ;
21589 PyObject * obj1 = 0 ;
21590 char *kwnames[] = {
21591 (char *) "self",(char *) "tz", NULL
21592 };
21593
21594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21596 if (SWIG_arg_fail(1)) SWIG_fail;
21597 if (obj1) {
21598 {
21599 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21600 temp2 = true;
21601 }
21602 }
21603 {
21604 PyThreadState* __tstate = wxPyBeginAllowThreads();
21605 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21606
21607 wxPyEndAllowThreads(__tstate);
21608 if (PyErr_Occurred()) SWIG_fail;
21609 }
21610 {
21611 resultobj = SWIG_From_int((int)(result));
21612 }
21613 {
21614 if (temp2) delete arg2;
21615 }
21616 return resultobj;
21617 fail:
21618 {
21619 if (temp2) delete arg2;
21620 }
21621 return NULL;
21622 }
21623
21624
21625 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21626 PyObject *resultobj;
21627 wxDateTime *arg1 = (wxDateTime *) 0 ;
21628 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21629 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21630 int result;
21631 bool temp2 = false ;
21632 PyObject * obj0 = 0 ;
21633 PyObject * obj1 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self",(char *) "tz", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 if (obj1) {
21642 {
21643 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21644 temp2 = true;
21645 }
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21650
21651 wxPyEndAllowThreads(__tstate);
21652 if (PyErr_Occurred()) SWIG_fail;
21653 }
21654 {
21655 resultobj = SWIG_From_int((int)(result));
21656 }
21657 {
21658 if (temp2) delete arg2;
21659 }
21660 return resultobj;
21661 fail:
21662 {
21663 if (temp2) delete arg2;
21664 }
21665 return NULL;
21666 }
21667
21668
21669 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21670 PyObject *resultobj;
21671 wxDateTime *arg1 = (wxDateTime *) 0 ;
21672 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21673 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21674 int result;
21675 bool temp2 = false ;
21676 PyObject * obj0 = 0 ;
21677 PyObject * obj1 = 0 ;
21678 char *kwnames[] = {
21679 (char *) "self",(char *) "tz", NULL
21680 };
21681
21682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21684 if (SWIG_arg_fail(1)) SWIG_fail;
21685 if (obj1) {
21686 {
21687 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21688 temp2 = true;
21689 }
21690 }
21691 {
21692 PyThreadState* __tstate = wxPyBeginAllowThreads();
21693 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21694
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 {
21699 resultobj = SWIG_From_int((int)(result));
21700 }
21701 {
21702 if (temp2) delete arg2;
21703 }
21704 return resultobj;
21705 fail:
21706 {
21707 if (temp2) delete arg2;
21708 }
21709 return NULL;
21710 }
21711
21712
21713 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21714 PyObject *resultobj;
21715 wxDateTime *arg1 = (wxDateTime *) 0 ;
21716 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21717 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21718 int result;
21719 bool temp2 = false ;
21720 PyObject * obj0 = 0 ;
21721 PyObject * obj1 = 0 ;
21722 char *kwnames[] = {
21723 (char *) "self",(char *) "tz", NULL
21724 };
21725
21726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21728 if (SWIG_arg_fail(1)) SWIG_fail;
21729 if (obj1) {
21730 {
21731 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21732 temp2 = true;
21733 }
21734 }
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21738
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 {
21743 resultobj = SWIG_From_int((int)(result));
21744 }
21745 {
21746 if (temp2) delete arg2;
21747 }
21748 return resultobj;
21749 fail:
21750 {
21751 if (temp2) delete arg2;
21752 }
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 wxDateTime *arg1 = (wxDateTime *) 0 ;
21760 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21761 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21762 int result;
21763 bool temp2 = false ;
21764 PyObject * obj0 = 0 ;
21765 PyObject * obj1 = 0 ;
21766 char *kwnames[] = {
21767 (char *) "self",(char *) "tz", NULL
21768 };
21769
21770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21772 if (SWIG_arg_fail(1)) SWIG_fail;
21773 if (obj1) {
21774 {
21775 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21776 temp2 = true;
21777 }
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 {
21787 resultobj = SWIG_From_int((int)(result));
21788 }
21789 {
21790 if (temp2) delete arg2;
21791 }
21792 return resultobj;
21793 fail:
21794 {
21795 if (temp2) delete arg2;
21796 }
21797 return NULL;
21798 }
21799
21800
21801 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21802 PyObject *resultobj;
21803 wxDateTime *arg1 = (wxDateTime *) 0 ;
21804 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21805 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21806 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21807 int result;
21808 bool temp3 = false ;
21809 PyObject * obj0 = 0 ;
21810 PyObject * obj1 = 0 ;
21811 PyObject * obj2 = 0 ;
21812 char *kwnames[] = {
21813 (char *) "self",(char *) "flags",(char *) "tz", NULL
21814 };
21815
21816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21818 if (SWIG_arg_fail(1)) SWIG_fail;
21819 if (obj1) {
21820 {
21821 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21822 if (SWIG_arg_fail(2)) SWIG_fail;
21823 }
21824 }
21825 if (obj2) {
21826 {
21827 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21828 temp3 = true;
21829 }
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21834
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 {
21839 resultobj = SWIG_From_int((int)(result));
21840 }
21841 {
21842 if (temp3) delete arg3;
21843 }
21844 return resultobj;
21845 fail:
21846 {
21847 if (temp3) delete arg3;
21848 }
21849 return NULL;
21850 }
21851
21852
21853 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21854 PyObject *resultobj;
21855 wxDateTime *arg1 = (wxDateTime *) 0 ;
21856 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21857 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21858 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21859 int result;
21860 bool temp3 = false ;
21861 PyObject * obj0 = 0 ;
21862 PyObject * obj1 = 0 ;
21863 PyObject * obj2 = 0 ;
21864 char *kwnames[] = {
21865 (char *) "self",(char *) "flags",(char *) "tz", NULL
21866 };
21867
21868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21870 if (SWIG_arg_fail(1)) SWIG_fail;
21871 if (obj1) {
21872 {
21873 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21874 if (SWIG_arg_fail(2)) SWIG_fail;
21875 }
21876 }
21877 if (obj2) {
21878 {
21879 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21880 temp3 = true;
21881 }
21882 }
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21886
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 {
21891 resultobj = SWIG_From_int((int)(result));
21892 }
21893 {
21894 if (temp3) delete arg3;
21895 }
21896 return resultobj;
21897 fail:
21898 {
21899 if (temp3) delete arg3;
21900 }
21901 return NULL;
21902 }
21903
21904
21905 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21906 PyObject *resultobj;
21907 wxDateTime *arg1 = (wxDateTime *) 0 ;
21908 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21909 bool result;
21910 PyObject * obj0 = 0 ;
21911 PyObject * obj1 = 0 ;
21912 char *kwnames[] = {
21913 (char *) "self",(char *) "country", NULL
21914 };
21915
21916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21918 if (SWIG_arg_fail(1)) SWIG_fail;
21919 if (obj1) {
21920 {
21921 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21922 if (SWIG_arg_fail(2)) SWIG_fail;
21923 }
21924 }
21925 {
21926 PyThreadState* __tstate = wxPyBeginAllowThreads();
21927 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21928
21929 wxPyEndAllowThreads(__tstate);
21930 if (PyErr_Occurred()) SWIG_fail;
21931 }
21932 {
21933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21934 }
21935 return resultobj;
21936 fail:
21937 return NULL;
21938 }
21939
21940
21941 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21942 PyObject *resultobj;
21943 wxDateTime *arg1 = (wxDateTime *) 0 ;
21944 wxDateTime *arg2 = 0 ;
21945 bool result;
21946 PyObject * obj0 = 0 ;
21947 PyObject * obj1 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self",(char *) "datetime", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 {
21956 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21957 if (SWIG_arg_fail(2)) SWIG_fail;
21958 if (arg2 == NULL) {
21959 SWIG_null_ref("wxDateTime");
21960 }
21961 if (SWIG_arg_fail(2)) SWIG_fail;
21962 }
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21966
21967 wxPyEndAllowThreads(__tstate);
21968 if (PyErr_Occurred()) SWIG_fail;
21969 }
21970 {
21971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21972 }
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 wxDateTime *arg1 = (wxDateTime *) 0 ;
21982 wxDateTime *arg2 = 0 ;
21983 bool result;
21984 PyObject * obj0 = 0 ;
21985 PyObject * obj1 = 0 ;
21986 char *kwnames[] = {
21987 (char *) "self",(char *) "datetime", NULL
21988 };
21989
21990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
21991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21992 if (SWIG_arg_fail(1)) SWIG_fail;
21993 {
21994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21995 if (SWIG_arg_fail(2)) SWIG_fail;
21996 if (arg2 == NULL) {
21997 SWIG_null_ref("wxDateTime");
21998 }
21999 if (SWIG_arg_fail(2)) SWIG_fail;
22000 }
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22004
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj;
22019 wxDateTime *arg1 = (wxDateTime *) 0 ;
22020 wxDateTime *arg2 = 0 ;
22021 bool result;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char *kwnames[] = {
22025 (char *) "self",(char *) "datetime", NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22030 if (SWIG_arg_fail(1)) SWIG_fail;
22031 {
22032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22033 if (SWIG_arg_fail(2)) SWIG_fail;
22034 if (arg2 == NULL) {
22035 SWIG_null_ref("wxDateTime");
22036 }
22037 if (SWIG_arg_fail(2)) SWIG_fail;
22038 }
22039 {
22040 PyThreadState* __tstate = wxPyBeginAllowThreads();
22041 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22042
22043 wxPyEndAllowThreads(__tstate);
22044 if (PyErr_Occurred()) SWIG_fail;
22045 }
22046 {
22047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22048 }
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj;
22057 wxDateTime *arg1 = (wxDateTime *) 0 ;
22058 wxDateTime *arg2 = 0 ;
22059 wxDateTime *arg3 = 0 ;
22060 bool result;
22061 PyObject * obj0 = 0 ;
22062 PyObject * obj1 = 0 ;
22063 PyObject * obj2 = 0 ;
22064 char *kwnames[] = {
22065 (char *) "self",(char *) "t1",(char *) "t2", NULL
22066 };
22067
22068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22070 if (SWIG_arg_fail(1)) SWIG_fail;
22071 {
22072 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22073 if (SWIG_arg_fail(2)) SWIG_fail;
22074 if (arg2 == NULL) {
22075 SWIG_null_ref("wxDateTime");
22076 }
22077 if (SWIG_arg_fail(2)) SWIG_fail;
22078 }
22079 {
22080 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22081 if (SWIG_arg_fail(3)) SWIG_fail;
22082 if (arg3 == NULL) {
22083 SWIG_null_ref("wxDateTime");
22084 }
22085 if (SWIG_arg_fail(3)) SWIG_fail;
22086 }
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22090
22091 wxPyEndAllowThreads(__tstate);
22092 if (PyErr_Occurred()) SWIG_fail;
22093 }
22094 {
22095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22096 }
22097 return resultobj;
22098 fail:
22099 return NULL;
22100 }
22101
22102
22103 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22104 PyObject *resultobj;
22105 wxDateTime *arg1 = (wxDateTime *) 0 ;
22106 wxDateTime *arg2 = 0 ;
22107 wxDateTime *arg3 = 0 ;
22108 bool result;
22109 PyObject * obj0 = 0 ;
22110 PyObject * obj1 = 0 ;
22111 PyObject * obj2 = 0 ;
22112 char *kwnames[] = {
22113 (char *) "self",(char *) "t1",(char *) "t2", NULL
22114 };
22115
22116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22118 if (SWIG_arg_fail(1)) SWIG_fail;
22119 {
22120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22121 if (SWIG_arg_fail(2)) SWIG_fail;
22122 if (arg2 == NULL) {
22123 SWIG_null_ref("wxDateTime");
22124 }
22125 if (SWIG_arg_fail(2)) SWIG_fail;
22126 }
22127 {
22128 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22129 if (SWIG_arg_fail(3)) SWIG_fail;
22130 if (arg3 == NULL) {
22131 SWIG_null_ref("wxDateTime");
22132 }
22133 if (SWIG_arg_fail(3)) SWIG_fail;
22134 }
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22138
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 {
22143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22144 }
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22152 PyObject *resultobj;
22153 wxDateTime *arg1 = (wxDateTime *) 0 ;
22154 wxDateTime *arg2 = 0 ;
22155 bool result;
22156 PyObject * obj0 = 0 ;
22157 PyObject * obj1 = 0 ;
22158 char *kwnames[] = {
22159 (char *) "self",(char *) "dt", NULL
22160 };
22161
22162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22164 if (SWIG_arg_fail(1)) SWIG_fail;
22165 {
22166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22167 if (SWIG_arg_fail(2)) SWIG_fail;
22168 if (arg2 == NULL) {
22169 SWIG_null_ref("wxDateTime");
22170 }
22171 if (SWIG_arg_fail(2)) SWIG_fail;
22172 }
22173 {
22174 PyThreadState* __tstate = wxPyBeginAllowThreads();
22175 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22176
22177 wxPyEndAllowThreads(__tstate);
22178 if (PyErr_Occurred()) SWIG_fail;
22179 }
22180 {
22181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22182 }
22183 return resultobj;
22184 fail:
22185 return NULL;
22186 }
22187
22188
22189 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22190 PyObject *resultobj;
22191 wxDateTime *arg1 = (wxDateTime *) 0 ;
22192 wxDateTime *arg2 = 0 ;
22193 bool result;
22194 PyObject * obj0 = 0 ;
22195 PyObject * obj1 = 0 ;
22196 char *kwnames[] = {
22197 (char *) "self",(char *) "dt", NULL
22198 };
22199
22200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22202 if (SWIG_arg_fail(1)) SWIG_fail;
22203 {
22204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22205 if (SWIG_arg_fail(2)) SWIG_fail;
22206 if (arg2 == NULL) {
22207 SWIG_null_ref("wxDateTime");
22208 }
22209 if (SWIG_arg_fail(2)) SWIG_fail;
22210 }
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22214
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 {
22219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22220 }
22221 return resultobj;
22222 fail:
22223 return NULL;
22224 }
22225
22226
22227 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj;
22229 wxDateTime *arg1 = (wxDateTime *) 0 ;
22230 wxDateTime *arg2 = 0 ;
22231 wxTimeSpan *arg3 = 0 ;
22232 bool result;
22233 PyObject * obj0 = 0 ;
22234 PyObject * obj1 = 0 ;
22235 PyObject * obj2 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "self",(char *) "dt",(char *) "ts", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22242 if (SWIG_arg_fail(1)) SWIG_fail;
22243 {
22244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22245 if (SWIG_arg_fail(2)) SWIG_fail;
22246 if (arg2 == NULL) {
22247 SWIG_null_ref("wxDateTime");
22248 }
22249 if (SWIG_arg_fail(2)) SWIG_fail;
22250 }
22251 {
22252 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22253 if (SWIG_arg_fail(3)) SWIG_fail;
22254 if (arg3 == NULL) {
22255 SWIG_null_ref("wxTimeSpan");
22256 }
22257 if (SWIG_arg_fail(3)) SWIG_fail;
22258 }
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22262
22263 wxPyEndAllowThreads(__tstate);
22264 if (PyErr_Occurred()) SWIG_fail;
22265 }
22266 {
22267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22268 }
22269 return resultobj;
22270 fail:
22271 return NULL;
22272 }
22273
22274
22275 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22276 PyObject *resultobj;
22277 wxDateTime *arg1 = (wxDateTime *) 0 ;
22278 wxTimeSpan *arg2 = 0 ;
22279 wxDateTime *result;
22280 PyObject * obj0 = 0 ;
22281 PyObject * obj1 = 0 ;
22282 char *kwnames[] = {
22283 (char *) "self",(char *) "diff", NULL
22284 };
22285
22286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22288 if (SWIG_arg_fail(1)) SWIG_fail;
22289 {
22290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22291 if (SWIG_arg_fail(2)) SWIG_fail;
22292 if (arg2 == NULL) {
22293 SWIG_null_ref("wxTimeSpan");
22294 }
22295 if (SWIG_arg_fail(2)) SWIG_fail;
22296 }
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 {
22300 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22301 result = (wxDateTime *) &_result_ref;
22302 }
22303
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22308 return resultobj;
22309 fail:
22310 return NULL;
22311 }
22312
22313
22314 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22315 PyObject *resultobj;
22316 wxDateTime *arg1 = (wxDateTime *) 0 ;
22317 wxDateSpan *arg2 = 0 ;
22318 wxDateTime *result;
22319 PyObject * obj0 = 0 ;
22320 PyObject * obj1 = 0 ;
22321 char *kwnames[] = {
22322 (char *) "self",(char *) "diff", NULL
22323 };
22324
22325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22327 if (SWIG_arg_fail(1)) SWIG_fail;
22328 {
22329 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22330 if (SWIG_arg_fail(2)) SWIG_fail;
22331 if (arg2 == NULL) {
22332 SWIG_null_ref("wxDateSpan");
22333 }
22334 if (SWIG_arg_fail(2)) SWIG_fail;
22335 }
22336 {
22337 PyThreadState* __tstate = wxPyBeginAllowThreads();
22338 {
22339 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22340 result = (wxDateTime *) &_result_ref;
22341 }
22342
22343 wxPyEndAllowThreads(__tstate);
22344 if (PyErr_Occurred()) SWIG_fail;
22345 }
22346 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22347 return resultobj;
22348 fail:
22349 return NULL;
22350 }
22351
22352
22353 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22354 PyObject *resultobj;
22355 wxDateTime *arg1 = (wxDateTime *) 0 ;
22356 wxTimeSpan *arg2 = 0 ;
22357 wxDateTime *result;
22358 PyObject * obj0 = 0 ;
22359 PyObject * obj1 = 0 ;
22360 char *kwnames[] = {
22361 (char *) "self",(char *) "diff", NULL
22362 };
22363
22364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22366 if (SWIG_arg_fail(1)) SWIG_fail;
22367 {
22368 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22369 if (SWIG_arg_fail(2)) SWIG_fail;
22370 if (arg2 == NULL) {
22371 SWIG_null_ref("wxTimeSpan");
22372 }
22373 if (SWIG_arg_fail(2)) SWIG_fail;
22374 }
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 {
22378 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22379 result = (wxDateTime *) &_result_ref;
22380 }
22381
22382 wxPyEndAllowThreads(__tstate);
22383 if (PyErr_Occurred()) SWIG_fail;
22384 }
22385 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22386 return resultobj;
22387 fail:
22388 return NULL;
22389 }
22390
22391
22392 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22393 PyObject *resultobj;
22394 wxDateTime *arg1 = (wxDateTime *) 0 ;
22395 wxDateSpan *arg2 = 0 ;
22396 wxDateTime *result;
22397 PyObject * obj0 = 0 ;
22398 PyObject * obj1 = 0 ;
22399 char *kwnames[] = {
22400 (char *) "self",(char *) "diff", NULL
22401 };
22402
22403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22405 if (SWIG_arg_fail(1)) SWIG_fail;
22406 {
22407 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(2)) SWIG_fail;
22409 if (arg2 == NULL) {
22410 SWIG_null_ref("wxDateSpan");
22411 }
22412 if (SWIG_arg_fail(2)) SWIG_fail;
22413 }
22414 {
22415 PyThreadState* __tstate = wxPyBeginAllowThreads();
22416 {
22417 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22418 result = (wxDateTime *) &_result_ref;
22419 }
22420
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj;
22433 wxDateTime *arg1 = (wxDateTime *) 0 ;
22434 wxDateTime *arg2 = 0 ;
22435 wxTimeSpan result;
22436 PyObject * obj0 = 0 ;
22437 PyObject * obj1 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self",(char *) "dt", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22447 if (SWIG_arg_fail(2)) SWIG_fail;
22448 if (arg2 == NULL) {
22449 SWIG_null_ref("wxDateTime");
22450 }
22451 if (SWIG_arg_fail(2)) SWIG_fail;
22452 }
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22456
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 {
22461 wxTimeSpan * resultptr;
22462 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22463 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22464 }
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22472 PyObject *resultobj;
22473 wxDateTime *arg1 = (wxDateTime *) 0 ;
22474 wxTimeSpan *arg2 = 0 ;
22475 wxDateTime *result;
22476 PyObject * obj0 = 0 ;
22477 PyObject * obj1 = 0 ;
22478
22479 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22481 if (SWIG_arg_fail(1)) SWIG_fail;
22482 {
22483 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22484 if (SWIG_arg_fail(2)) SWIG_fail;
22485 if (arg2 == NULL) {
22486 SWIG_null_ref("wxTimeSpan");
22487 }
22488 if (SWIG_arg_fail(2)) SWIG_fail;
22489 }
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 {
22493 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22494 result = (wxDateTime *) &_result_ref;
22495 }
22496
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22508 PyObject *resultobj;
22509 wxDateTime *arg1 = (wxDateTime *) 0 ;
22510 wxDateSpan *arg2 = 0 ;
22511 wxDateTime *result;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514
22515 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22517 if (SWIG_arg_fail(1)) SWIG_fail;
22518 {
22519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 if (arg2 == NULL) {
22522 SWIG_null_ref("wxDateSpan");
22523 }
22524 if (SWIG_arg_fail(2)) SWIG_fail;
22525 }
22526 {
22527 PyThreadState* __tstate = wxPyBeginAllowThreads();
22528 {
22529 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22530 result = (wxDateTime *) &_result_ref;
22531 }
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22544 int argc;
22545 PyObject *argv[3];
22546 int ii;
22547
22548 argc = PyObject_Length(args);
22549 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22550 argv[ii] = PyTuple_GetItem(args,ii);
22551 }
22552 if (argc == 2) {
22553 int _v;
22554 {
22555 void *ptr;
22556 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22557 _v = 0;
22558 PyErr_Clear();
22559 } else {
22560 _v = 1;
22561 }
22562 }
22563 if (_v) {
22564 {
22565 void *ptr = 0;
22566 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22567 _v = 0;
22568 PyErr_Clear();
22569 } else {
22570 _v = (ptr != 0);
22571 }
22572 }
22573 if (_v) {
22574 return _wrap_DateTime___iadd____SWIG_0(self,args);
22575 }
22576 }
22577 }
22578 if (argc == 2) {
22579 int _v;
22580 {
22581 void *ptr;
22582 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22583 _v = 0;
22584 PyErr_Clear();
22585 } else {
22586 _v = 1;
22587 }
22588 }
22589 if (_v) {
22590 {
22591 void *ptr = 0;
22592 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22593 _v = 0;
22594 PyErr_Clear();
22595 } else {
22596 _v = (ptr != 0);
22597 }
22598 }
22599 if (_v) {
22600 return _wrap_DateTime___iadd____SWIG_1(self,args);
22601 }
22602 }
22603 }
22604
22605 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22606 return NULL;
22607 }
22608
22609
22610 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22611 PyObject *resultobj;
22612 wxDateTime *arg1 = (wxDateTime *) 0 ;
22613 wxTimeSpan *arg2 = 0 ;
22614 wxDateTime *result;
22615 PyObject * obj0 = 0 ;
22616 PyObject * obj1 = 0 ;
22617
22618 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22620 if (SWIG_arg_fail(1)) SWIG_fail;
22621 {
22622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22623 if (SWIG_arg_fail(2)) SWIG_fail;
22624 if (arg2 == NULL) {
22625 SWIG_null_ref("wxTimeSpan");
22626 }
22627 if (SWIG_arg_fail(2)) SWIG_fail;
22628 }
22629 {
22630 PyThreadState* __tstate = wxPyBeginAllowThreads();
22631 {
22632 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22633 result = (wxDateTime *) &_result_ref;
22634 }
22635
22636 wxPyEndAllowThreads(__tstate);
22637 if (PyErr_Occurred()) SWIG_fail;
22638 }
22639 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22640 return resultobj;
22641 fail:
22642 return NULL;
22643 }
22644
22645
22646 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22647 PyObject *resultobj;
22648 wxDateTime *arg1 = (wxDateTime *) 0 ;
22649 wxDateSpan *arg2 = 0 ;
22650 wxDateTime *result;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653
22654 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22656 if (SWIG_arg_fail(1)) SWIG_fail;
22657 {
22658 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22659 if (SWIG_arg_fail(2)) SWIG_fail;
22660 if (arg2 == NULL) {
22661 SWIG_null_ref("wxDateSpan");
22662 }
22663 if (SWIG_arg_fail(2)) SWIG_fail;
22664 }
22665 {
22666 PyThreadState* __tstate = wxPyBeginAllowThreads();
22667 {
22668 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22669 result = (wxDateTime *) &_result_ref;
22670 }
22671
22672 wxPyEndAllowThreads(__tstate);
22673 if (PyErr_Occurred()) SWIG_fail;
22674 }
22675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22676 return resultobj;
22677 fail:
22678 return NULL;
22679 }
22680
22681
22682 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22683 int argc;
22684 PyObject *argv[3];
22685 int ii;
22686
22687 argc = PyObject_Length(args);
22688 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22689 argv[ii] = PyTuple_GetItem(args,ii);
22690 }
22691 if (argc == 2) {
22692 int _v;
22693 {
22694 void *ptr;
22695 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22696 _v = 0;
22697 PyErr_Clear();
22698 } else {
22699 _v = 1;
22700 }
22701 }
22702 if (_v) {
22703 {
22704 void *ptr = 0;
22705 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22706 _v = 0;
22707 PyErr_Clear();
22708 } else {
22709 _v = (ptr != 0);
22710 }
22711 }
22712 if (_v) {
22713 return _wrap_DateTime___isub____SWIG_0(self,args);
22714 }
22715 }
22716 }
22717 if (argc == 2) {
22718 int _v;
22719 {
22720 void *ptr;
22721 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22722 _v = 0;
22723 PyErr_Clear();
22724 } else {
22725 _v = 1;
22726 }
22727 }
22728 if (_v) {
22729 {
22730 void *ptr = 0;
22731 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22732 _v = 0;
22733 PyErr_Clear();
22734 } else {
22735 _v = (ptr != 0);
22736 }
22737 }
22738 if (_v) {
22739 return _wrap_DateTime___isub____SWIG_1(self,args);
22740 }
22741 }
22742 }
22743
22744 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22745 return NULL;
22746 }
22747
22748
22749 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22750 PyObject *resultobj;
22751 wxDateTime *arg1 = (wxDateTime *) 0 ;
22752 wxTimeSpan *arg2 = 0 ;
22753 wxDateTime result;
22754 PyObject * obj0 = 0 ;
22755 PyObject * obj1 = 0 ;
22756
22757 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22759 if (SWIG_arg_fail(1)) SWIG_fail;
22760 {
22761 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22762 if (SWIG_arg_fail(2)) SWIG_fail;
22763 if (arg2 == NULL) {
22764 SWIG_null_ref("wxTimeSpan");
22765 }
22766 if (SWIG_arg_fail(2)) SWIG_fail;
22767 }
22768 {
22769 PyThreadState* __tstate = wxPyBeginAllowThreads();
22770 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22771
22772 wxPyEndAllowThreads(__tstate);
22773 if (PyErr_Occurred()) SWIG_fail;
22774 }
22775 {
22776 wxDateTime * resultptr;
22777 resultptr = new wxDateTime((wxDateTime &)(result));
22778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22779 }
22780 return resultobj;
22781 fail:
22782 return NULL;
22783 }
22784
22785
22786 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22787 PyObject *resultobj;
22788 wxDateTime *arg1 = (wxDateTime *) 0 ;
22789 wxDateSpan *arg2 = 0 ;
22790 wxDateTime result;
22791 PyObject * obj0 = 0 ;
22792 PyObject * obj1 = 0 ;
22793
22794 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22796 if (SWIG_arg_fail(1)) SWIG_fail;
22797 {
22798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22799 if (SWIG_arg_fail(2)) SWIG_fail;
22800 if (arg2 == NULL) {
22801 SWIG_null_ref("wxDateSpan");
22802 }
22803 if (SWIG_arg_fail(2)) SWIG_fail;
22804 }
22805 {
22806 PyThreadState* __tstate = wxPyBeginAllowThreads();
22807 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22808
22809 wxPyEndAllowThreads(__tstate);
22810 if (PyErr_Occurred()) SWIG_fail;
22811 }
22812 {
22813 wxDateTime * resultptr;
22814 resultptr = new wxDateTime((wxDateTime &)(result));
22815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22816 }
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22824 int argc;
22825 PyObject *argv[3];
22826 int ii;
22827
22828 argc = PyObject_Length(args);
22829 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22830 argv[ii] = PyTuple_GetItem(args,ii);
22831 }
22832 if (argc == 2) {
22833 int _v;
22834 {
22835 void *ptr;
22836 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22837 _v = 0;
22838 PyErr_Clear();
22839 } else {
22840 _v = 1;
22841 }
22842 }
22843 if (_v) {
22844 {
22845 void *ptr = 0;
22846 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22847 _v = 0;
22848 PyErr_Clear();
22849 } else {
22850 _v = (ptr != 0);
22851 }
22852 }
22853 if (_v) {
22854 return _wrap_DateTime___add____SWIG_0(self,args);
22855 }
22856 }
22857 }
22858 if (argc == 2) {
22859 int _v;
22860 {
22861 void *ptr;
22862 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22863 _v = 0;
22864 PyErr_Clear();
22865 } else {
22866 _v = 1;
22867 }
22868 }
22869 if (_v) {
22870 {
22871 void *ptr = 0;
22872 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22873 _v = 0;
22874 PyErr_Clear();
22875 } else {
22876 _v = (ptr != 0);
22877 }
22878 }
22879 if (_v) {
22880 return _wrap_DateTime___add____SWIG_1(self,args);
22881 }
22882 }
22883 }
22884
22885 Py_INCREF(Py_NotImplemented);
22886 return Py_NotImplemented;
22887 }
22888
22889
22890 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22891 PyObject *resultobj;
22892 wxDateTime *arg1 = (wxDateTime *) 0 ;
22893 wxDateTime *arg2 = 0 ;
22894 wxTimeSpan result;
22895 PyObject * obj0 = 0 ;
22896 PyObject * obj1 = 0 ;
22897
22898 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22900 if (SWIG_arg_fail(1)) SWIG_fail;
22901 {
22902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22903 if (SWIG_arg_fail(2)) SWIG_fail;
22904 if (arg2 == NULL) {
22905 SWIG_null_ref("wxDateTime");
22906 }
22907 if (SWIG_arg_fail(2)) SWIG_fail;
22908 }
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22912
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 {
22917 wxTimeSpan * resultptr;
22918 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22928 PyObject *resultobj;
22929 wxDateTime *arg1 = (wxDateTime *) 0 ;
22930 wxTimeSpan *arg2 = 0 ;
22931 wxDateTime result;
22932 PyObject * obj0 = 0 ;
22933 PyObject * obj1 = 0 ;
22934
22935 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22937 if (SWIG_arg_fail(1)) SWIG_fail;
22938 {
22939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22940 if (SWIG_arg_fail(2)) SWIG_fail;
22941 if (arg2 == NULL) {
22942 SWIG_null_ref("wxTimeSpan");
22943 }
22944 if (SWIG_arg_fail(2)) SWIG_fail;
22945 }
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22949
22950 wxPyEndAllowThreads(__tstate);
22951 if (PyErr_Occurred()) SWIG_fail;
22952 }
22953 {
22954 wxDateTime * resultptr;
22955 resultptr = new wxDateTime((wxDateTime &)(result));
22956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22957 }
22958 return resultobj;
22959 fail:
22960 return NULL;
22961 }
22962
22963
22964 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22965 PyObject *resultobj;
22966 wxDateTime *arg1 = (wxDateTime *) 0 ;
22967 wxDateSpan *arg2 = 0 ;
22968 wxDateTime result;
22969 PyObject * obj0 = 0 ;
22970 PyObject * obj1 = 0 ;
22971
22972 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22974 if (SWIG_arg_fail(1)) SWIG_fail;
22975 {
22976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22977 if (SWIG_arg_fail(2)) SWIG_fail;
22978 if (arg2 == NULL) {
22979 SWIG_null_ref("wxDateSpan");
22980 }
22981 if (SWIG_arg_fail(2)) SWIG_fail;
22982 }
22983 {
22984 PyThreadState* __tstate = wxPyBeginAllowThreads();
22985 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
22986
22987 wxPyEndAllowThreads(__tstate);
22988 if (PyErr_Occurred()) SWIG_fail;
22989 }
22990 {
22991 wxDateTime * resultptr;
22992 resultptr = new wxDateTime((wxDateTime &)(result));
22993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22994 }
22995 return resultobj;
22996 fail:
22997 return NULL;
22998 }
22999
23000
23001 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23002 int argc;
23003 PyObject *argv[3];
23004 int ii;
23005
23006 argc = PyObject_Length(args);
23007 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23008 argv[ii] = PyTuple_GetItem(args,ii);
23009 }
23010 if (argc == 2) {
23011 int _v;
23012 {
23013 void *ptr;
23014 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23015 _v = 0;
23016 PyErr_Clear();
23017 } else {
23018 _v = 1;
23019 }
23020 }
23021 if (_v) {
23022 {
23023 void *ptr = 0;
23024 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23025 _v = 0;
23026 PyErr_Clear();
23027 } else {
23028 _v = (ptr != 0);
23029 }
23030 }
23031 if (_v) {
23032 return _wrap_DateTime___sub____SWIG_0(self,args);
23033 }
23034 }
23035 }
23036 if (argc == 2) {
23037 int _v;
23038 {
23039 void *ptr;
23040 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23041 _v = 0;
23042 PyErr_Clear();
23043 } else {
23044 _v = 1;
23045 }
23046 }
23047 if (_v) {
23048 {
23049 void *ptr = 0;
23050 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23051 _v = 0;
23052 PyErr_Clear();
23053 } else {
23054 _v = (ptr != 0);
23055 }
23056 }
23057 if (_v) {
23058 return _wrap_DateTime___sub____SWIG_1(self,args);
23059 }
23060 }
23061 }
23062 if (argc == 2) {
23063 int _v;
23064 {
23065 void *ptr;
23066 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23067 _v = 0;
23068 PyErr_Clear();
23069 } else {
23070 _v = 1;
23071 }
23072 }
23073 if (_v) {
23074 {
23075 void *ptr = 0;
23076 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23077 _v = 0;
23078 PyErr_Clear();
23079 } else {
23080 _v = (ptr != 0);
23081 }
23082 }
23083 if (_v) {
23084 return _wrap_DateTime___sub____SWIG_2(self,args);
23085 }
23086 }
23087 }
23088
23089 Py_INCREF(Py_NotImplemented);
23090 return Py_NotImplemented;
23091 }
23092
23093
23094 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23095 PyObject *resultobj;
23096 wxDateTime *arg1 = (wxDateTime *) 0 ;
23097 wxDateTime *arg2 = (wxDateTime *) 0 ;
23098 bool result;
23099 PyObject * obj0 = 0 ;
23100 PyObject * obj1 = 0 ;
23101 char *kwnames[] = {
23102 (char *) "self",(char *) "other", NULL
23103 };
23104
23105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23107 if (SWIG_arg_fail(1)) SWIG_fail;
23108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23109 if (SWIG_arg_fail(2)) SWIG_fail;
23110 {
23111 PyThreadState* __tstate = wxPyBeginAllowThreads();
23112 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23113
23114 wxPyEndAllowThreads(__tstate);
23115 if (PyErr_Occurred()) SWIG_fail;
23116 }
23117 {
23118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23119 }
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23127 PyObject *resultobj;
23128 wxDateTime *arg1 = (wxDateTime *) 0 ;
23129 wxDateTime *arg2 = (wxDateTime *) 0 ;
23130 bool result;
23131 PyObject * obj0 = 0 ;
23132 PyObject * obj1 = 0 ;
23133 char *kwnames[] = {
23134 (char *) "self",(char *) "other", NULL
23135 };
23136
23137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23139 if (SWIG_arg_fail(1)) SWIG_fail;
23140 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23141 if (SWIG_arg_fail(2)) SWIG_fail;
23142 {
23143 PyThreadState* __tstate = wxPyBeginAllowThreads();
23144 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23145
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 {
23150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23151 }
23152 return resultobj;
23153 fail:
23154 return NULL;
23155 }
23156
23157
23158 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23159 PyObject *resultobj;
23160 wxDateTime *arg1 = (wxDateTime *) 0 ;
23161 wxDateTime *arg2 = (wxDateTime *) 0 ;
23162 bool result;
23163 PyObject * obj0 = 0 ;
23164 PyObject * obj1 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self",(char *) "other", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23173 if (SWIG_arg_fail(2)) SWIG_fail;
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23177
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 {
23182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23183 }
23184 return resultobj;
23185 fail:
23186 return NULL;
23187 }
23188
23189
23190 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23191 PyObject *resultobj;
23192 wxDateTime *arg1 = (wxDateTime *) 0 ;
23193 wxDateTime *arg2 = (wxDateTime *) 0 ;
23194 bool result;
23195 PyObject * obj0 = 0 ;
23196 PyObject * obj1 = 0 ;
23197 char *kwnames[] = {
23198 (char *) "self",(char *) "other", NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23205 if (SWIG_arg_fail(2)) SWIG_fail;
23206 {
23207 PyThreadState* __tstate = wxPyBeginAllowThreads();
23208 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23209
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 {
23214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23215 }
23216 return resultobj;
23217 fail:
23218 return NULL;
23219 }
23220
23221
23222 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23223 PyObject *resultobj;
23224 wxDateTime *arg1 = (wxDateTime *) 0 ;
23225 wxDateTime *arg2 = (wxDateTime *) 0 ;
23226 bool result;
23227 PyObject * obj0 = 0 ;
23228 PyObject * obj1 = 0 ;
23229 char *kwnames[] = {
23230 (char *) "self",(char *) "other", NULL
23231 };
23232
23233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(1)) SWIG_fail;
23236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23237 if (SWIG_arg_fail(2)) SWIG_fail;
23238 {
23239 PyThreadState* __tstate = wxPyBeginAllowThreads();
23240 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23241
23242 wxPyEndAllowThreads(__tstate);
23243 if (PyErr_Occurred()) SWIG_fail;
23244 }
23245 {
23246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23247 }
23248 return resultobj;
23249 fail:
23250 return NULL;
23251 }
23252
23253
23254 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23255 PyObject *resultobj;
23256 wxDateTime *arg1 = (wxDateTime *) 0 ;
23257 wxDateTime *arg2 = (wxDateTime *) 0 ;
23258 bool result;
23259 PyObject * obj0 = 0 ;
23260 PyObject * obj1 = 0 ;
23261 char *kwnames[] = {
23262 (char *) "self",(char *) "other", NULL
23263 };
23264
23265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23267 if (SWIG_arg_fail(1)) SWIG_fail;
23268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23269 if (SWIG_arg_fail(2)) SWIG_fail;
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 {
23278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23279 }
23280 return resultobj;
23281 fail:
23282 return NULL;
23283 }
23284
23285
23286 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23287 PyObject *resultobj;
23288 wxDateTime *arg1 = (wxDateTime *) 0 ;
23289 wxString *arg2 = 0 ;
23290 int result;
23291 bool temp2 = false ;
23292 PyObject * obj0 = 0 ;
23293 PyObject * obj1 = 0 ;
23294 char *kwnames[] = {
23295 (char *) "self",(char *) "date", NULL
23296 };
23297
23298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23300 if (SWIG_arg_fail(1)) SWIG_fail;
23301 {
23302 arg2 = wxString_in_helper(obj1);
23303 if (arg2 == NULL) SWIG_fail;
23304 temp2 = true;
23305 }
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23309
23310 wxPyEndAllowThreads(__tstate);
23311 if (PyErr_Occurred()) SWIG_fail;
23312 }
23313 {
23314 resultobj = SWIG_From_int((int)(result));
23315 }
23316 {
23317 if (temp2)
23318 delete arg2;
23319 }
23320 return resultobj;
23321 fail:
23322 {
23323 if (temp2)
23324 delete arg2;
23325 }
23326 return NULL;
23327 }
23328
23329
23330 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj;
23332 wxDateTime *arg1 = (wxDateTime *) 0 ;
23333 wxString *arg2 = 0 ;
23334 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23335 wxString *arg3 = (wxString *) &arg3_defvalue ;
23336 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23337 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23338 int result;
23339 bool temp2 = false ;
23340 bool temp3 = false ;
23341 PyObject * obj0 = 0 ;
23342 PyObject * obj1 = 0 ;
23343 PyObject * obj2 = 0 ;
23344 PyObject * obj3 = 0 ;
23345 char *kwnames[] = {
23346 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23347 };
23348
23349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23351 if (SWIG_arg_fail(1)) SWIG_fail;
23352 {
23353 arg2 = wxString_in_helper(obj1);
23354 if (arg2 == NULL) SWIG_fail;
23355 temp2 = true;
23356 }
23357 if (obj2) {
23358 {
23359 arg3 = wxString_in_helper(obj2);
23360 if (arg3 == NULL) SWIG_fail;
23361 temp3 = true;
23362 }
23363 }
23364 if (obj3) {
23365 {
23366 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23367 if (SWIG_arg_fail(4)) SWIG_fail;
23368 if (arg4 == NULL) {
23369 SWIG_null_ref("wxDateTime");
23370 }
23371 if (SWIG_arg_fail(4)) SWIG_fail;
23372 }
23373 }
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23377
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = SWIG_From_int((int)(result));
23383 }
23384 {
23385 if (temp2)
23386 delete arg2;
23387 }
23388 {
23389 if (temp3)
23390 delete arg3;
23391 }
23392 return resultobj;
23393 fail:
23394 {
23395 if (temp2)
23396 delete arg2;
23397 }
23398 {
23399 if (temp3)
23400 delete arg3;
23401 }
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj;
23408 wxDateTime *arg1 = (wxDateTime *) 0 ;
23409 wxString *arg2 = 0 ;
23410 int result;
23411 bool temp2 = false ;
23412 PyObject * obj0 = 0 ;
23413 PyObject * obj1 = 0 ;
23414 char *kwnames[] = {
23415 (char *) "self",(char *) "datetime", NULL
23416 };
23417
23418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23420 if (SWIG_arg_fail(1)) SWIG_fail;
23421 {
23422 arg2 = wxString_in_helper(obj1);
23423 if (arg2 == NULL) SWIG_fail;
23424 temp2 = true;
23425 }
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23429
23430 wxPyEndAllowThreads(__tstate);
23431 if (PyErr_Occurred()) SWIG_fail;
23432 }
23433 {
23434 resultobj = SWIG_From_int((int)(result));
23435 }
23436 {
23437 if (temp2)
23438 delete arg2;
23439 }
23440 return resultobj;
23441 fail:
23442 {
23443 if (temp2)
23444 delete arg2;
23445 }
23446 return NULL;
23447 }
23448
23449
23450 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23451 PyObject *resultobj;
23452 wxDateTime *arg1 = (wxDateTime *) 0 ;
23453 wxString *arg2 = 0 ;
23454 int result;
23455 bool temp2 = false ;
23456 PyObject * obj0 = 0 ;
23457 PyObject * obj1 = 0 ;
23458 char *kwnames[] = {
23459 (char *) "self",(char *) "date", NULL
23460 };
23461
23462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23464 if (SWIG_arg_fail(1)) SWIG_fail;
23465 {
23466 arg2 = wxString_in_helper(obj1);
23467 if (arg2 == NULL) SWIG_fail;
23468 temp2 = true;
23469 }
23470 {
23471 PyThreadState* __tstate = wxPyBeginAllowThreads();
23472 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23473
23474 wxPyEndAllowThreads(__tstate);
23475 if (PyErr_Occurred()) SWIG_fail;
23476 }
23477 {
23478 resultobj = SWIG_From_int((int)(result));
23479 }
23480 {
23481 if (temp2)
23482 delete arg2;
23483 }
23484 return resultobj;
23485 fail:
23486 {
23487 if (temp2)
23488 delete arg2;
23489 }
23490 return NULL;
23491 }
23492
23493
23494 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23495 PyObject *resultobj;
23496 wxDateTime *arg1 = (wxDateTime *) 0 ;
23497 wxString *arg2 = 0 ;
23498 int result;
23499 bool temp2 = false ;
23500 PyObject * obj0 = 0 ;
23501 PyObject * obj1 = 0 ;
23502 char *kwnames[] = {
23503 (char *) "self",(char *) "time", NULL
23504 };
23505
23506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23508 if (SWIG_arg_fail(1)) SWIG_fail;
23509 {
23510 arg2 = wxString_in_helper(obj1);
23511 if (arg2 == NULL) SWIG_fail;
23512 temp2 = true;
23513 }
23514 {
23515 PyThreadState* __tstate = wxPyBeginAllowThreads();
23516 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23517
23518 wxPyEndAllowThreads(__tstate);
23519 if (PyErr_Occurred()) SWIG_fail;
23520 }
23521 {
23522 resultobj = SWIG_From_int((int)(result));
23523 }
23524 {
23525 if (temp2)
23526 delete arg2;
23527 }
23528 return resultobj;
23529 fail:
23530 {
23531 if (temp2)
23532 delete arg2;
23533 }
23534 return NULL;
23535 }
23536
23537
23538 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23539 PyObject *resultobj;
23540 wxDateTime *arg1 = (wxDateTime *) 0 ;
23541 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23542 wxString *arg2 = (wxString *) &arg2_defvalue ;
23543 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23544 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23545 wxString result;
23546 bool temp2 = false ;
23547 bool temp3 = false ;
23548 PyObject * obj0 = 0 ;
23549 PyObject * obj1 = 0 ;
23550 PyObject * obj2 = 0 ;
23551 char *kwnames[] = {
23552 (char *) "self",(char *) "format",(char *) "tz", NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23557 if (SWIG_arg_fail(1)) SWIG_fail;
23558 if (obj1) {
23559 {
23560 arg2 = wxString_in_helper(obj1);
23561 if (arg2 == NULL) SWIG_fail;
23562 temp2 = true;
23563 }
23564 }
23565 if (obj2) {
23566 {
23567 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23568 temp3 = true;
23569 }
23570 }
23571 {
23572 PyThreadState* __tstate = wxPyBeginAllowThreads();
23573 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23574
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 #if wxUSE_UNICODE
23580 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23581 #else
23582 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23583 #endif
23584 }
23585 {
23586 if (temp2)
23587 delete arg2;
23588 }
23589 {
23590 if (temp3) delete arg3;
23591 }
23592 return resultobj;
23593 fail:
23594 {
23595 if (temp2)
23596 delete arg2;
23597 }
23598 {
23599 if (temp3) delete arg3;
23600 }
23601 return NULL;
23602 }
23603
23604
23605 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23606 PyObject *resultobj;
23607 wxDateTime *arg1 = (wxDateTime *) 0 ;
23608 wxString result;
23609 PyObject * obj0 = 0 ;
23610 char *kwnames[] = {
23611 (char *) "self", NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23616 if (SWIG_arg_fail(1)) SWIG_fail;
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = ((wxDateTime const *)arg1)->FormatDate();
23620
23621 wxPyEndAllowThreads(__tstate);
23622 if (PyErr_Occurred()) SWIG_fail;
23623 }
23624 {
23625 #if wxUSE_UNICODE
23626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23627 #else
23628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23629 #endif
23630 }
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23638 PyObject *resultobj;
23639 wxDateTime *arg1 = (wxDateTime *) 0 ;
23640 wxString result;
23641 PyObject * obj0 = 0 ;
23642 char *kwnames[] = {
23643 (char *) "self", NULL
23644 };
23645
23646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23648 if (SWIG_arg_fail(1)) SWIG_fail;
23649 {
23650 PyThreadState* __tstate = wxPyBeginAllowThreads();
23651 result = ((wxDateTime const *)arg1)->FormatTime();
23652
23653 wxPyEndAllowThreads(__tstate);
23654 if (PyErr_Occurred()) SWIG_fail;
23655 }
23656 {
23657 #if wxUSE_UNICODE
23658 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23659 #else
23660 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23661 #endif
23662 }
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj;
23671 wxDateTime *arg1 = (wxDateTime *) 0 ;
23672 wxString result;
23673 PyObject * obj0 = 0 ;
23674 char *kwnames[] = {
23675 (char *) "self", NULL
23676 };
23677
23678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23680 if (SWIG_arg_fail(1)) SWIG_fail;
23681 {
23682 PyThreadState* __tstate = wxPyBeginAllowThreads();
23683 result = ((wxDateTime const *)arg1)->FormatISODate();
23684
23685 wxPyEndAllowThreads(__tstate);
23686 if (PyErr_Occurred()) SWIG_fail;
23687 }
23688 {
23689 #if wxUSE_UNICODE
23690 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23691 #else
23692 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23693 #endif
23694 }
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23702 PyObject *resultobj;
23703 wxDateTime *arg1 = (wxDateTime *) 0 ;
23704 wxString result;
23705 PyObject * obj0 = 0 ;
23706 char *kwnames[] = {
23707 (char *) "self", NULL
23708 };
23709
23710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23712 if (SWIG_arg_fail(1)) SWIG_fail;
23713 {
23714 PyThreadState* __tstate = wxPyBeginAllowThreads();
23715 result = ((wxDateTime const *)arg1)->FormatISOTime();
23716
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 {
23721 #if wxUSE_UNICODE
23722 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23723 #else
23724 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23725 #endif
23726 }
23727 return resultobj;
23728 fail:
23729 return NULL;
23730 }
23731
23732
23733 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23734 PyObject *obj;
23735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23736 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23737 Py_INCREF(obj);
23738 return Py_BuildValue((char *)"");
23739 }
23740 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23741 PyObject *resultobj;
23742 long arg1 ;
23743 wxTimeSpan result;
23744 PyObject * obj0 = 0 ;
23745 char *kwnames[] = {
23746 (char *) "sec", NULL
23747 };
23748
23749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23750 {
23751 arg1 = (long)(SWIG_As_long(obj0));
23752 if (SWIG_arg_fail(1)) SWIG_fail;
23753 }
23754 {
23755 PyThreadState* __tstate = wxPyBeginAllowThreads();
23756 result = wxTimeSpan::Seconds(arg1);
23757
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 {
23762 wxTimeSpan * resultptr;
23763 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23765 }
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23773 PyObject *resultobj;
23774 wxTimeSpan result;
23775 char *kwnames[] = {
23776 NULL
23777 };
23778
23779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = wxTimeSpan::Second();
23783
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 {
23788 wxTimeSpan * resultptr;
23789 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23790 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23791 }
23792 return resultobj;
23793 fail:
23794 return NULL;
23795 }
23796
23797
23798 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23799 PyObject *resultobj;
23800 long arg1 ;
23801 wxTimeSpan result;
23802 PyObject * obj0 = 0 ;
23803 char *kwnames[] = {
23804 (char *) "min", NULL
23805 };
23806
23807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23808 {
23809 arg1 = (long)(SWIG_As_long(obj0));
23810 if (SWIG_arg_fail(1)) SWIG_fail;
23811 }
23812 {
23813 PyThreadState* __tstate = wxPyBeginAllowThreads();
23814 result = wxTimeSpan::Minutes(arg1);
23815
23816 wxPyEndAllowThreads(__tstate);
23817 if (PyErr_Occurred()) SWIG_fail;
23818 }
23819 {
23820 wxTimeSpan * resultptr;
23821 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23822 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23823 }
23824 return resultobj;
23825 fail:
23826 return NULL;
23827 }
23828
23829
23830 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23831 PyObject *resultobj;
23832 wxTimeSpan result;
23833 char *kwnames[] = {
23834 NULL
23835 };
23836
23837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = wxTimeSpan::Minute();
23841
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 {
23846 wxTimeSpan * resultptr;
23847 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23848 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23849 }
23850 return resultobj;
23851 fail:
23852 return NULL;
23853 }
23854
23855
23856 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23857 PyObject *resultobj;
23858 long arg1 ;
23859 wxTimeSpan result;
23860 PyObject * obj0 = 0 ;
23861 char *kwnames[] = {
23862 (char *) "hours", NULL
23863 };
23864
23865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23866 {
23867 arg1 = (long)(SWIG_As_long(obj0));
23868 if (SWIG_arg_fail(1)) SWIG_fail;
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = wxTimeSpan::Hours(arg1);
23873
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 {
23878 wxTimeSpan * resultptr;
23879 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23881 }
23882 return resultobj;
23883 fail:
23884 return NULL;
23885 }
23886
23887
23888 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23889 PyObject *resultobj;
23890 wxTimeSpan result;
23891 char *kwnames[] = {
23892 NULL
23893 };
23894
23895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23896 {
23897 PyThreadState* __tstate = wxPyBeginAllowThreads();
23898 result = wxTimeSpan::Hour();
23899
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 {
23904 wxTimeSpan * resultptr;
23905 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23907 }
23908 return resultobj;
23909 fail:
23910 return NULL;
23911 }
23912
23913
23914 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23915 PyObject *resultobj;
23916 long arg1 ;
23917 wxTimeSpan result;
23918 PyObject * obj0 = 0 ;
23919 char *kwnames[] = {
23920 (char *) "days", NULL
23921 };
23922
23923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23924 {
23925 arg1 = (long)(SWIG_As_long(obj0));
23926 if (SWIG_arg_fail(1)) SWIG_fail;
23927 }
23928 {
23929 PyThreadState* __tstate = wxPyBeginAllowThreads();
23930 result = wxTimeSpan::Days(arg1);
23931
23932 wxPyEndAllowThreads(__tstate);
23933 if (PyErr_Occurred()) SWIG_fail;
23934 }
23935 {
23936 wxTimeSpan * resultptr;
23937 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23938 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23939 }
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23947 PyObject *resultobj;
23948 wxTimeSpan result;
23949 char *kwnames[] = {
23950 NULL
23951 };
23952
23953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23954 {
23955 PyThreadState* __tstate = wxPyBeginAllowThreads();
23956 result = wxTimeSpan::Day();
23957
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 {
23962 wxTimeSpan * resultptr;
23963 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23964 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23965 }
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
23973 PyObject *resultobj;
23974 long arg1 ;
23975 wxTimeSpan result;
23976 PyObject * obj0 = 0 ;
23977 char *kwnames[] = {
23978 (char *) "days", NULL
23979 };
23980
23981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
23982 {
23983 arg1 = (long)(SWIG_As_long(obj0));
23984 if (SWIG_arg_fail(1)) SWIG_fail;
23985 }
23986 {
23987 PyThreadState* __tstate = wxPyBeginAllowThreads();
23988 result = wxTimeSpan::Weeks(arg1);
23989
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 {
23994 wxTimeSpan * resultptr;
23995 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23996 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23997 }
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24005 PyObject *resultobj;
24006 wxTimeSpan result;
24007 char *kwnames[] = {
24008 NULL
24009 };
24010
24011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24012 {
24013 PyThreadState* __tstate = wxPyBeginAllowThreads();
24014 result = wxTimeSpan::Week();
24015
24016 wxPyEndAllowThreads(__tstate);
24017 if (PyErr_Occurred()) SWIG_fail;
24018 }
24019 {
24020 wxTimeSpan * resultptr;
24021 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24023 }
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj;
24032 long arg1 = (long) 0 ;
24033 long arg2 = (long) 0 ;
24034 long arg3 = (long) 0 ;
24035 long arg4 = (long) 0 ;
24036 wxTimeSpan *result;
24037 PyObject * obj0 = 0 ;
24038 PyObject * obj1 = 0 ;
24039 PyObject * obj2 = 0 ;
24040 PyObject * obj3 = 0 ;
24041 char *kwnames[] = {
24042 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24043 };
24044
24045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24046 if (obj0) {
24047 {
24048 arg1 = (long)(SWIG_As_long(obj0));
24049 if (SWIG_arg_fail(1)) SWIG_fail;
24050 }
24051 }
24052 if (obj1) {
24053 {
24054 arg2 = (long)(SWIG_As_long(obj1));
24055 if (SWIG_arg_fail(2)) SWIG_fail;
24056 }
24057 }
24058 if (obj2) {
24059 {
24060 arg3 = (long)(SWIG_As_long(obj2));
24061 if (SWIG_arg_fail(3)) SWIG_fail;
24062 }
24063 }
24064 if (obj3) {
24065 {
24066 arg4 = (long)(SWIG_As_long(obj3));
24067 if (SWIG_arg_fail(4)) SWIG_fail;
24068 }
24069 }
24070 {
24071 PyThreadState* __tstate = wxPyBeginAllowThreads();
24072 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24073
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24085 PyObject *resultobj;
24086 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24087 PyObject * obj0 = 0 ;
24088 char *kwnames[] = {
24089 (char *) "self", NULL
24090 };
24091
24092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24094 if (SWIG_arg_fail(1)) SWIG_fail;
24095 {
24096 PyThreadState* __tstate = wxPyBeginAllowThreads();
24097 delete arg1;
24098
24099 wxPyEndAllowThreads(__tstate);
24100 if (PyErr_Occurred()) SWIG_fail;
24101 }
24102 Py_INCREF(Py_None); resultobj = Py_None;
24103 return resultobj;
24104 fail:
24105 return NULL;
24106 }
24107
24108
24109 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24110 PyObject *resultobj;
24111 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24112 wxTimeSpan *arg2 = 0 ;
24113 wxTimeSpan *result;
24114 PyObject * obj0 = 0 ;
24115 PyObject * obj1 = 0 ;
24116 char *kwnames[] = {
24117 (char *) "self",(char *) "diff", NULL
24118 };
24119
24120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24122 if (SWIG_arg_fail(1)) SWIG_fail;
24123 {
24124 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24125 if (SWIG_arg_fail(2)) SWIG_fail;
24126 if (arg2 == NULL) {
24127 SWIG_null_ref("wxTimeSpan");
24128 }
24129 if (SWIG_arg_fail(2)) SWIG_fail;
24130 }
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 {
24134 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24135 result = (wxTimeSpan *) &_result_ref;
24136 }
24137
24138 wxPyEndAllowThreads(__tstate);
24139 if (PyErr_Occurred()) SWIG_fail;
24140 }
24141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24142 return resultobj;
24143 fail:
24144 return NULL;
24145 }
24146
24147
24148 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24149 PyObject *resultobj;
24150 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24151 wxTimeSpan *arg2 = 0 ;
24152 wxTimeSpan *result;
24153 PyObject * obj0 = 0 ;
24154 PyObject * obj1 = 0 ;
24155 char *kwnames[] = {
24156 (char *) "self",(char *) "diff", NULL
24157 };
24158
24159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24161 if (SWIG_arg_fail(1)) SWIG_fail;
24162 {
24163 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24164 if (SWIG_arg_fail(2)) SWIG_fail;
24165 if (arg2 == NULL) {
24166 SWIG_null_ref("wxTimeSpan");
24167 }
24168 if (SWIG_arg_fail(2)) SWIG_fail;
24169 }
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 {
24173 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24174 result = (wxTimeSpan *) &_result_ref;
24175 }
24176
24177 wxPyEndAllowThreads(__tstate);
24178 if (PyErr_Occurred()) SWIG_fail;
24179 }
24180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24181 return resultobj;
24182 fail:
24183 return NULL;
24184 }
24185
24186
24187 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24188 PyObject *resultobj;
24189 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24190 int arg2 ;
24191 wxTimeSpan *result;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char *kwnames[] = {
24195 (char *) "self",(char *) "n", NULL
24196 };
24197
24198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24200 if (SWIG_arg_fail(1)) SWIG_fail;
24201 {
24202 arg2 = (int)(SWIG_As_int(obj1));
24203 if (SWIG_arg_fail(2)) SWIG_fail;
24204 }
24205 {
24206 PyThreadState* __tstate = wxPyBeginAllowThreads();
24207 {
24208 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
24209 result = (wxTimeSpan *) &_result_ref;
24210 }
24211
24212 wxPyEndAllowThreads(__tstate);
24213 if (PyErr_Occurred()) SWIG_fail;
24214 }
24215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24216 return resultobj;
24217 fail:
24218 return NULL;
24219 }
24220
24221
24222 static PyObject *_wrap_TimeSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
24223 PyObject *resultobj;
24224 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24225 wxTimeSpan *result;
24226 PyObject * obj0 = 0 ;
24227 char *kwnames[] = {
24228 (char *) "self", NULL
24229 };
24230
24231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Neg",kwnames,&obj0)) goto fail;
24232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24233 if (SWIG_arg_fail(1)) SWIG_fail;
24234 {
24235 PyThreadState* __tstate = wxPyBeginAllowThreads();
24236 {
24237 wxTimeSpan &_result_ref = (arg1)->Neg();
24238 result = (wxTimeSpan *) &_result_ref;
24239 }
24240
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24245 return resultobj;
24246 fail:
24247 return NULL;
24248 }
24249
24250
24251 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24252 PyObject *resultobj;
24253 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24254 wxTimeSpan result;
24255 PyObject * obj0 = 0 ;
24256 char *kwnames[] = {
24257 (char *) "self", NULL
24258 };
24259
24260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24262 if (SWIG_arg_fail(1)) SWIG_fail;
24263 {
24264 PyThreadState* __tstate = wxPyBeginAllowThreads();
24265 result = ((wxTimeSpan const *)arg1)->Abs();
24266
24267 wxPyEndAllowThreads(__tstate);
24268 if (PyErr_Occurred()) SWIG_fail;
24269 }
24270 {
24271 wxTimeSpan * resultptr;
24272 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24273 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24274 }
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24282 PyObject *resultobj;
24283 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24284 wxTimeSpan *arg2 = 0 ;
24285 wxTimeSpan *result;
24286 PyObject * obj0 = 0 ;
24287 PyObject * obj1 = 0 ;
24288 char *kwnames[] = {
24289 (char *) "self",(char *) "diff", NULL
24290 };
24291
24292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24294 if (SWIG_arg_fail(1)) SWIG_fail;
24295 {
24296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24297 if (SWIG_arg_fail(2)) SWIG_fail;
24298 if (arg2 == NULL) {
24299 SWIG_null_ref("wxTimeSpan");
24300 }
24301 if (SWIG_arg_fail(2)) SWIG_fail;
24302 }
24303 {
24304 PyThreadState* __tstate = wxPyBeginAllowThreads();
24305 {
24306 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24307 result = (wxTimeSpan *) &_result_ref;
24308 }
24309
24310 wxPyEndAllowThreads(__tstate);
24311 if (PyErr_Occurred()) SWIG_fail;
24312 }
24313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24321 PyObject *resultobj;
24322 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24323 wxTimeSpan *arg2 = 0 ;
24324 wxTimeSpan *result;
24325 PyObject * obj0 = 0 ;
24326 PyObject * obj1 = 0 ;
24327 char *kwnames[] = {
24328 (char *) "self",(char *) "diff", NULL
24329 };
24330
24331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24333 if (SWIG_arg_fail(1)) SWIG_fail;
24334 {
24335 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24336 if (SWIG_arg_fail(2)) SWIG_fail;
24337 if (arg2 == NULL) {
24338 SWIG_null_ref("wxTimeSpan");
24339 }
24340 if (SWIG_arg_fail(2)) SWIG_fail;
24341 }
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 {
24345 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24346 result = (wxTimeSpan *) &_result_ref;
24347 }
24348
24349 wxPyEndAllowThreads(__tstate);
24350 if (PyErr_Occurred()) SWIG_fail;
24351 }
24352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24353 return resultobj;
24354 fail:
24355 return NULL;
24356 }
24357
24358
24359 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24360 PyObject *resultobj;
24361 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24362 int arg2 ;
24363 wxTimeSpan *result;
24364 PyObject * obj0 = 0 ;
24365 PyObject * obj1 = 0 ;
24366 char *kwnames[] = {
24367 (char *) "self",(char *) "n", NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24372 if (SWIG_arg_fail(1)) SWIG_fail;
24373 {
24374 arg2 = (int)(SWIG_As_int(obj1));
24375 if (SWIG_arg_fail(2)) SWIG_fail;
24376 }
24377 {
24378 PyThreadState* __tstate = wxPyBeginAllowThreads();
24379 {
24380 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
24381 result = (wxTimeSpan *) &_result_ref;
24382 }
24383
24384 wxPyEndAllowThreads(__tstate);
24385 if (PyErr_Occurred()) SWIG_fail;
24386 }
24387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24388 return resultobj;
24389 fail:
24390 return NULL;
24391 }
24392
24393
24394 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24395 PyObject *resultobj;
24396 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24397 wxTimeSpan *result;
24398 PyObject * obj0 = 0 ;
24399 char *kwnames[] = {
24400 (char *) "self", NULL
24401 };
24402
24403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24405 if (SWIG_arg_fail(1)) SWIG_fail;
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 {
24409 wxTimeSpan &_result_ref = (arg1)->operator -();
24410 result = (wxTimeSpan *) &_result_ref;
24411 }
24412
24413 wxPyEndAllowThreads(__tstate);
24414 if (PyErr_Occurred()) SWIG_fail;
24415 }
24416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj;
24425 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24426 wxTimeSpan *arg2 = 0 ;
24427 wxTimeSpan result;
24428 PyObject * obj0 = 0 ;
24429 PyObject * obj1 = 0 ;
24430 char *kwnames[] = {
24431 (char *) "self",(char *) "other", NULL
24432 };
24433
24434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24436 if (SWIG_arg_fail(1)) SWIG_fail;
24437 {
24438 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24439 if (SWIG_arg_fail(2)) SWIG_fail;
24440 if (arg2 == NULL) {
24441 SWIG_null_ref("wxTimeSpan");
24442 }
24443 if (SWIG_arg_fail(2)) SWIG_fail;
24444 }
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24448
24449 wxPyEndAllowThreads(__tstate);
24450 if (PyErr_Occurred()) SWIG_fail;
24451 }
24452 {
24453 wxTimeSpan * resultptr;
24454 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24455 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24456 }
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24464 PyObject *resultobj;
24465 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24466 wxTimeSpan *arg2 = 0 ;
24467 wxTimeSpan result;
24468 PyObject * obj0 = 0 ;
24469 PyObject * obj1 = 0 ;
24470 char *kwnames[] = {
24471 (char *) "self",(char *) "other", NULL
24472 };
24473
24474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24476 if (SWIG_arg_fail(1)) SWIG_fail;
24477 {
24478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24479 if (SWIG_arg_fail(2)) SWIG_fail;
24480 if (arg2 == NULL) {
24481 SWIG_null_ref("wxTimeSpan");
24482 }
24483 if (SWIG_arg_fail(2)) SWIG_fail;
24484 }
24485 {
24486 PyThreadState* __tstate = wxPyBeginAllowThreads();
24487 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24488
24489 wxPyEndAllowThreads(__tstate);
24490 if (PyErr_Occurred()) SWIG_fail;
24491 }
24492 {
24493 wxTimeSpan * resultptr;
24494 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24495 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24496 }
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24504 PyObject *resultobj;
24505 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24506 int arg2 ;
24507 wxTimeSpan result;
24508 PyObject * obj0 = 0 ;
24509 PyObject * obj1 = 0 ;
24510 char *kwnames[] = {
24511 (char *) "self",(char *) "n", NULL
24512 };
24513
24514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24516 if (SWIG_arg_fail(1)) SWIG_fail;
24517 {
24518 arg2 = (int)(SWIG_As_int(obj1));
24519 if (SWIG_arg_fail(2)) SWIG_fail;
24520 }
24521 {
24522 PyThreadState* __tstate = wxPyBeginAllowThreads();
24523 result = wxTimeSpan___mul__(arg1,arg2);
24524
24525 wxPyEndAllowThreads(__tstate);
24526 if (PyErr_Occurred()) SWIG_fail;
24527 }
24528 {
24529 wxTimeSpan * resultptr;
24530 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24532 }
24533 return resultobj;
24534 fail:
24535 return NULL;
24536 }
24537
24538
24539 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24540 PyObject *resultobj;
24541 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24542 int arg2 ;
24543 wxTimeSpan result;
24544 PyObject * obj0 = 0 ;
24545 PyObject * obj1 = 0 ;
24546 char *kwnames[] = {
24547 (char *) "self",(char *) "n", NULL
24548 };
24549
24550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24552 if (SWIG_arg_fail(1)) SWIG_fail;
24553 {
24554 arg2 = (int)(SWIG_As_int(obj1));
24555 if (SWIG_arg_fail(2)) SWIG_fail;
24556 }
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = wxTimeSpan___rmul__(arg1,arg2);
24560
24561 wxPyEndAllowThreads(__tstate);
24562 if (PyErr_Occurred()) SWIG_fail;
24563 }
24564 {
24565 wxTimeSpan * resultptr;
24566 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24568 }
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24576 PyObject *resultobj;
24577 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24578 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24579 bool result;
24580 PyObject * obj0 = 0 ;
24581 PyObject * obj1 = 0 ;
24582 char *kwnames[] = {
24583 (char *) "self",(char *) "other", NULL
24584 };
24585
24586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24588 if (SWIG_arg_fail(1)) SWIG_fail;
24589 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24590 if (SWIG_arg_fail(2)) SWIG_fail;
24591 {
24592 PyThreadState* __tstate = wxPyBeginAllowThreads();
24593 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24594
24595 wxPyEndAllowThreads(__tstate);
24596 if (PyErr_Occurred()) SWIG_fail;
24597 }
24598 {
24599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24600 }
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj;
24609 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24610 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24611 bool result;
24612 PyObject * obj0 = 0 ;
24613 PyObject * obj1 = 0 ;
24614 char *kwnames[] = {
24615 (char *) "self",(char *) "other", NULL
24616 };
24617
24618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24620 if (SWIG_arg_fail(1)) SWIG_fail;
24621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24622 if (SWIG_arg_fail(2)) SWIG_fail;
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24626
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 {
24631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24632 }
24633 return resultobj;
24634 fail:
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24642 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24643 bool result;
24644 PyObject * obj0 = 0 ;
24645 PyObject * obj1 = 0 ;
24646 char *kwnames[] = {
24647 (char *) "self",(char *) "other", NULL
24648 };
24649
24650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24652 if (SWIG_arg_fail(1)) SWIG_fail;
24653 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24654 if (SWIG_arg_fail(2)) SWIG_fail;
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24658
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 {
24663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24672 PyObject *resultobj;
24673 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24674 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24675 bool result;
24676 PyObject * obj0 = 0 ;
24677 PyObject * obj1 = 0 ;
24678 char *kwnames[] = {
24679 (char *) "self",(char *) "other", NULL
24680 };
24681
24682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24684 if (SWIG_arg_fail(1)) SWIG_fail;
24685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24686 if (SWIG_arg_fail(2)) SWIG_fail;
24687 {
24688 PyThreadState* __tstate = wxPyBeginAllowThreads();
24689 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24690
24691 wxPyEndAllowThreads(__tstate);
24692 if (PyErr_Occurred()) SWIG_fail;
24693 }
24694 {
24695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24696 }
24697 return resultobj;
24698 fail:
24699 return NULL;
24700 }
24701
24702
24703 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24704 PyObject *resultobj;
24705 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24706 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24707 bool result;
24708 PyObject * obj0 = 0 ;
24709 PyObject * obj1 = 0 ;
24710 char *kwnames[] = {
24711 (char *) "self",(char *) "other", NULL
24712 };
24713
24714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24716 if (SWIG_arg_fail(1)) SWIG_fail;
24717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24718 if (SWIG_arg_fail(2)) SWIG_fail;
24719 {
24720 PyThreadState* __tstate = wxPyBeginAllowThreads();
24721 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24722
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 {
24727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24728 }
24729 return resultobj;
24730 fail:
24731 return NULL;
24732 }
24733
24734
24735 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24736 PyObject *resultobj;
24737 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24738 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24739 bool result;
24740 PyObject * obj0 = 0 ;
24741 PyObject * obj1 = 0 ;
24742 char *kwnames[] = {
24743 (char *) "self",(char *) "other", NULL
24744 };
24745
24746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24748 if (SWIG_arg_fail(1)) SWIG_fail;
24749 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24750 if (SWIG_arg_fail(2)) SWIG_fail;
24751 {
24752 PyThreadState* __tstate = wxPyBeginAllowThreads();
24753 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24754
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 {
24759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24760 }
24761 return resultobj;
24762 fail:
24763 return NULL;
24764 }
24765
24766
24767 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj;
24769 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24770 bool result;
24771 PyObject * obj0 = 0 ;
24772 char *kwnames[] = {
24773 (char *) "self", NULL
24774 };
24775
24776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24778 if (SWIG_arg_fail(1)) SWIG_fail;
24779 {
24780 PyThreadState* __tstate = wxPyBeginAllowThreads();
24781 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24782
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24788 }
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj;
24797 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24798 bool result;
24799 PyObject * obj0 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj;
24825 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24826 bool result;
24827 PyObject * obj0 = 0 ;
24828 char *kwnames[] = {
24829 (char *) "self", NULL
24830 };
24831
24832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(1)) SWIG_fail;
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 {
24843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24844 }
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24854 wxTimeSpan *arg2 = 0 ;
24855 bool result;
24856 PyObject * obj0 = 0 ;
24857 PyObject * obj1 = 0 ;
24858 char *kwnames[] = {
24859 (char *) "self",(char *) "ts", NULL
24860 };
24861
24862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24864 if (SWIG_arg_fail(1)) SWIG_fail;
24865 {
24866 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24867 if (SWIG_arg_fail(2)) SWIG_fail;
24868 if (arg2 == NULL) {
24869 SWIG_null_ref("wxTimeSpan");
24870 }
24871 if (SWIG_arg_fail(2)) SWIG_fail;
24872 }
24873 {
24874 PyThreadState* __tstate = wxPyBeginAllowThreads();
24875 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24876
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 {
24881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24882 }
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj;
24891 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24892 wxTimeSpan *arg2 = 0 ;
24893 bool result;
24894 PyObject * obj0 = 0 ;
24895 PyObject * obj1 = 0 ;
24896 char *kwnames[] = {
24897 (char *) "self",(char *) "ts", NULL
24898 };
24899
24900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24902 if (SWIG_arg_fail(1)) SWIG_fail;
24903 {
24904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24905 if (SWIG_arg_fail(2)) SWIG_fail;
24906 if (arg2 == NULL) {
24907 SWIG_null_ref("wxTimeSpan");
24908 }
24909 if (SWIG_arg_fail(2)) SWIG_fail;
24910 }
24911 {
24912 PyThreadState* __tstate = wxPyBeginAllowThreads();
24913 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24914
24915 wxPyEndAllowThreads(__tstate);
24916 if (PyErr_Occurred()) SWIG_fail;
24917 }
24918 {
24919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24920 }
24921 return resultobj;
24922 fail:
24923 return NULL;
24924 }
24925
24926
24927 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24928 PyObject *resultobj;
24929 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24930 wxTimeSpan *arg2 = 0 ;
24931 bool result;
24932 PyObject * obj0 = 0 ;
24933 PyObject * obj1 = 0 ;
24934 char *kwnames[] = {
24935 (char *) "self",(char *) "t", NULL
24936 };
24937
24938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24940 if (SWIG_arg_fail(1)) SWIG_fail;
24941 {
24942 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24943 if (SWIG_arg_fail(2)) SWIG_fail;
24944 if (arg2 == NULL) {
24945 SWIG_null_ref("wxTimeSpan");
24946 }
24947 if (SWIG_arg_fail(2)) SWIG_fail;
24948 }
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24952
24953 wxPyEndAllowThreads(__tstate);
24954 if (PyErr_Occurred()) SWIG_fail;
24955 }
24956 {
24957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24958 }
24959 return resultobj;
24960 fail:
24961 return NULL;
24962 }
24963
24964
24965 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24966 PyObject *resultobj;
24967 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24968 int result;
24969 PyObject * obj0 = 0 ;
24970 char *kwnames[] = {
24971 (char *) "self", NULL
24972 };
24973
24974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
24975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24976 if (SWIG_arg_fail(1)) SWIG_fail;
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
24980
24981 wxPyEndAllowThreads(__tstate);
24982 if (PyErr_Occurred()) SWIG_fail;
24983 }
24984 {
24985 resultobj = SWIG_From_int((int)(result));
24986 }
24987 return resultobj;
24988 fail:
24989 return NULL;
24990 }
24991
24992
24993 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
24994 PyObject *resultobj;
24995 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24996 int result;
24997 PyObject * obj0 = 0 ;
24998 char *kwnames[] = {
24999 (char *) "self", NULL
25000 };
25001
25002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25004 if (SWIG_arg_fail(1)) SWIG_fail;
25005 {
25006 PyThreadState* __tstate = wxPyBeginAllowThreads();
25007 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25008
25009 wxPyEndAllowThreads(__tstate);
25010 if (PyErr_Occurred()) SWIG_fail;
25011 }
25012 {
25013 resultobj = SWIG_From_int((int)(result));
25014 }
25015 return resultobj;
25016 fail:
25017 return NULL;
25018 }
25019
25020
25021 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25022 PyObject *resultobj;
25023 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25024 int result;
25025 PyObject * obj0 = 0 ;
25026 char *kwnames[] = {
25027 (char *) "self", NULL
25028 };
25029
25030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25032 if (SWIG_arg_fail(1)) SWIG_fail;
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25036
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = SWIG_From_int((int)(result));
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj;
25051 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25052 int result;
25053 PyObject * obj0 = 0 ;
25054 char *kwnames[] = {
25055 (char *) "self", NULL
25056 };
25057
25058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25060 if (SWIG_arg_fail(1)) SWIG_fail;
25061 {
25062 PyThreadState* __tstate = wxPyBeginAllowThreads();
25063 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25064
25065 wxPyEndAllowThreads(__tstate);
25066 if (PyErr_Occurred()) SWIG_fail;
25067 }
25068 {
25069 resultobj = SWIG_From_int((int)(result));
25070 }
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj;
25079 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25080 wxLongLong result;
25081 PyObject * obj0 = 0 ;
25082 char *kwnames[] = {
25083 (char *) "self", NULL
25084 };
25085
25086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25088 if (SWIG_arg_fail(1)) SWIG_fail;
25089 {
25090 PyThreadState* __tstate = wxPyBeginAllowThreads();
25091 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25092
25093 wxPyEndAllowThreads(__tstate);
25094 if (PyErr_Occurred()) SWIG_fail;
25095 }
25096 {
25097 PyObject *hi, *lo, *shifter, *shifted;
25098 hi = PyLong_FromLong( (&result)->GetHi() );
25099 lo = PyLong_FromLong( (&result)->GetLo() );
25100 shifter = PyLong_FromLong(32);
25101 shifted = PyNumber_Lshift(hi, shifter);
25102 resultobj = PyNumber_Or(shifted, lo);
25103 Py_DECREF(hi);
25104 Py_DECREF(lo);
25105 Py_DECREF(shifter);
25106 Py_DECREF(shifted);
25107 }
25108 return resultobj;
25109 fail:
25110 return NULL;
25111 }
25112
25113
25114 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25115 PyObject *resultobj;
25116 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25117 wxLongLong result;
25118 PyObject * obj0 = 0 ;
25119 char *kwnames[] = {
25120 (char *) "self", NULL
25121 };
25122
25123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25125 if (SWIG_arg_fail(1)) SWIG_fail;
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25129
25130 wxPyEndAllowThreads(__tstate);
25131 if (PyErr_Occurred()) SWIG_fail;
25132 }
25133 {
25134 PyObject *hi, *lo, *shifter, *shifted;
25135 hi = PyLong_FromLong( (&result)->GetHi() );
25136 lo = PyLong_FromLong( (&result)->GetLo() );
25137 shifter = PyLong_FromLong(32);
25138 shifted = PyNumber_Lshift(hi, shifter);
25139 resultobj = PyNumber_Or(shifted, lo);
25140 Py_DECREF(hi);
25141 Py_DECREF(lo);
25142 Py_DECREF(shifter);
25143 Py_DECREF(shifted);
25144 }
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25152 PyObject *resultobj;
25153 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25154 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25155 wxString *arg2 = (wxString *) &arg2_defvalue ;
25156 wxString result;
25157 bool temp2 = false ;
25158 PyObject * obj0 = 0 ;
25159 PyObject * obj1 = 0 ;
25160 char *kwnames[] = {
25161 (char *) "self",(char *) "format", NULL
25162 };
25163
25164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25166 if (SWIG_arg_fail(1)) SWIG_fail;
25167 if (obj1) {
25168 {
25169 arg2 = wxString_in_helper(obj1);
25170 if (arg2 == NULL) SWIG_fail;
25171 temp2 = true;
25172 }
25173 }
25174 {
25175 PyThreadState* __tstate = wxPyBeginAllowThreads();
25176 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25177
25178 wxPyEndAllowThreads(__tstate);
25179 if (PyErr_Occurred()) SWIG_fail;
25180 }
25181 {
25182 #if wxUSE_UNICODE
25183 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25184 #else
25185 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25186 #endif
25187 }
25188 {
25189 if (temp2)
25190 delete arg2;
25191 }
25192 return resultobj;
25193 fail:
25194 {
25195 if (temp2)
25196 delete arg2;
25197 }
25198 return NULL;
25199 }
25200
25201
25202 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25203 PyObject *obj;
25204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25205 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25206 Py_INCREF(obj);
25207 return Py_BuildValue((char *)"");
25208 }
25209 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25210 PyObject *resultobj;
25211 int arg1 = (int) 0 ;
25212 int arg2 = (int) 0 ;
25213 int arg3 = (int) 0 ;
25214 int arg4 = (int) 0 ;
25215 wxDateSpan *result;
25216 PyObject * obj0 = 0 ;
25217 PyObject * obj1 = 0 ;
25218 PyObject * obj2 = 0 ;
25219 PyObject * obj3 = 0 ;
25220 char *kwnames[] = {
25221 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25222 };
25223
25224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25225 if (obj0) {
25226 {
25227 arg1 = (int)(SWIG_As_int(obj0));
25228 if (SWIG_arg_fail(1)) SWIG_fail;
25229 }
25230 }
25231 if (obj1) {
25232 {
25233 arg2 = (int)(SWIG_As_int(obj1));
25234 if (SWIG_arg_fail(2)) SWIG_fail;
25235 }
25236 }
25237 if (obj2) {
25238 {
25239 arg3 = (int)(SWIG_As_int(obj2));
25240 if (SWIG_arg_fail(3)) SWIG_fail;
25241 }
25242 }
25243 if (obj3) {
25244 {
25245 arg4 = (int)(SWIG_As_int(obj3));
25246 if (SWIG_arg_fail(4)) SWIG_fail;
25247 }
25248 }
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25252
25253 wxPyEndAllowThreads(__tstate);
25254 if (PyErr_Occurred()) SWIG_fail;
25255 }
25256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25264 PyObject *resultobj;
25265 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25266 PyObject * obj0 = 0 ;
25267 char *kwnames[] = {
25268 (char *) "self", NULL
25269 };
25270
25271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25273 if (SWIG_arg_fail(1)) SWIG_fail;
25274 {
25275 PyThreadState* __tstate = wxPyBeginAllowThreads();
25276 delete arg1;
25277
25278 wxPyEndAllowThreads(__tstate);
25279 if (PyErr_Occurred()) SWIG_fail;
25280 }
25281 Py_INCREF(Py_None); resultobj = Py_None;
25282 return resultobj;
25283 fail:
25284 return NULL;
25285 }
25286
25287
25288 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25289 PyObject *resultobj;
25290 int arg1 ;
25291 wxDateSpan result;
25292 PyObject * obj0 = 0 ;
25293 char *kwnames[] = {
25294 (char *) "days", NULL
25295 };
25296
25297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25298 {
25299 arg1 = (int)(SWIG_As_int(obj0));
25300 if (SWIG_arg_fail(1)) SWIG_fail;
25301 }
25302 {
25303 PyThreadState* __tstate = wxPyBeginAllowThreads();
25304 result = wxDateSpan::Days(arg1);
25305
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 {
25310 wxDateSpan * resultptr;
25311 resultptr = new wxDateSpan((wxDateSpan &)(result));
25312 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25313 }
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25321 PyObject *resultobj;
25322 wxDateSpan result;
25323 char *kwnames[] = {
25324 NULL
25325 };
25326
25327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25328 {
25329 PyThreadState* __tstate = wxPyBeginAllowThreads();
25330 result = wxDateSpan::Day();
25331
25332 wxPyEndAllowThreads(__tstate);
25333 if (PyErr_Occurred()) SWIG_fail;
25334 }
25335 {
25336 wxDateSpan * resultptr;
25337 resultptr = new wxDateSpan((wxDateSpan &)(result));
25338 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25339 }
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25347 PyObject *resultobj;
25348 int arg1 ;
25349 wxDateSpan result;
25350 PyObject * obj0 = 0 ;
25351 char *kwnames[] = {
25352 (char *) "weeks", NULL
25353 };
25354
25355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25356 {
25357 arg1 = (int)(SWIG_As_int(obj0));
25358 if (SWIG_arg_fail(1)) SWIG_fail;
25359 }
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 result = wxDateSpan::Weeks(arg1);
25363
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 {
25368 wxDateSpan * resultptr;
25369 resultptr = new wxDateSpan((wxDateSpan &)(result));
25370 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25371 }
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25379 PyObject *resultobj;
25380 wxDateSpan result;
25381 char *kwnames[] = {
25382 NULL
25383 };
25384
25385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25386 {
25387 PyThreadState* __tstate = wxPyBeginAllowThreads();
25388 result = wxDateSpan::Week();
25389
25390 wxPyEndAllowThreads(__tstate);
25391 if (PyErr_Occurred()) SWIG_fail;
25392 }
25393 {
25394 wxDateSpan * resultptr;
25395 resultptr = new wxDateSpan((wxDateSpan &)(result));
25396 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25397 }
25398 return resultobj;
25399 fail:
25400 return NULL;
25401 }
25402
25403
25404 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25405 PyObject *resultobj;
25406 int arg1 ;
25407 wxDateSpan result;
25408 PyObject * obj0 = 0 ;
25409 char *kwnames[] = {
25410 (char *) "mon", NULL
25411 };
25412
25413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25414 {
25415 arg1 = (int)(SWIG_As_int(obj0));
25416 if (SWIG_arg_fail(1)) SWIG_fail;
25417 }
25418 {
25419 PyThreadState* __tstate = wxPyBeginAllowThreads();
25420 result = wxDateSpan::Months(arg1);
25421
25422 wxPyEndAllowThreads(__tstate);
25423 if (PyErr_Occurred()) SWIG_fail;
25424 }
25425 {
25426 wxDateSpan * resultptr;
25427 resultptr = new wxDateSpan((wxDateSpan &)(result));
25428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25429 }
25430 return resultobj;
25431 fail:
25432 return NULL;
25433 }
25434
25435
25436 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25437 PyObject *resultobj;
25438 wxDateSpan result;
25439 char *kwnames[] = {
25440 NULL
25441 };
25442
25443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25444 {
25445 PyThreadState* __tstate = wxPyBeginAllowThreads();
25446 result = wxDateSpan::Month();
25447
25448 wxPyEndAllowThreads(__tstate);
25449 if (PyErr_Occurred()) SWIG_fail;
25450 }
25451 {
25452 wxDateSpan * resultptr;
25453 resultptr = new wxDateSpan((wxDateSpan &)(result));
25454 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25455 }
25456 return resultobj;
25457 fail:
25458 return NULL;
25459 }
25460
25461
25462 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25463 PyObject *resultobj;
25464 int arg1 ;
25465 wxDateSpan result;
25466 PyObject * obj0 = 0 ;
25467 char *kwnames[] = {
25468 (char *) "years", NULL
25469 };
25470
25471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25472 {
25473 arg1 = (int)(SWIG_As_int(obj0));
25474 if (SWIG_arg_fail(1)) SWIG_fail;
25475 }
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = wxDateSpan::Years(arg1);
25479
25480 wxPyEndAllowThreads(__tstate);
25481 if (PyErr_Occurred()) SWIG_fail;
25482 }
25483 {
25484 wxDateSpan * resultptr;
25485 resultptr = new wxDateSpan((wxDateSpan &)(result));
25486 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25487 }
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25495 PyObject *resultobj;
25496 wxDateSpan result;
25497 char *kwnames[] = {
25498 NULL
25499 };
25500
25501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25502 {
25503 PyThreadState* __tstate = wxPyBeginAllowThreads();
25504 result = wxDateSpan::Year();
25505
25506 wxPyEndAllowThreads(__tstate);
25507 if (PyErr_Occurred()) SWIG_fail;
25508 }
25509 {
25510 wxDateSpan * resultptr;
25511 resultptr = new wxDateSpan((wxDateSpan &)(result));
25512 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25513 }
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25521 PyObject *resultobj;
25522 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25523 int arg2 ;
25524 wxDateSpan *result;
25525 PyObject * obj0 = 0 ;
25526 PyObject * obj1 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self",(char *) "n", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 arg2 = (int)(SWIG_As_int(obj1));
25536 if (SWIG_arg_fail(2)) SWIG_fail;
25537 }
25538 {
25539 PyThreadState* __tstate = wxPyBeginAllowThreads();
25540 {
25541 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25542 result = (wxDateSpan *) &_result_ref;
25543 }
25544
25545 wxPyEndAllowThreads(__tstate);
25546 if (PyErr_Occurred()) SWIG_fail;
25547 }
25548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25556 PyObject *resultobj;
25557 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25558 int arg2 ;
25559 wxDateSpan *result;
25560 PyObject * obj0 = 0 ;
25561 PyObject * obj1 = 0 ;
25562 char *kwnames[] = {
25563 (char *) "self",(char *) "n", NULL
25564 };
25565
25566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25568 if (SWIG_arg_fail(1)) SWIG_fail;
25569 {
25570 arg2 = (int)(SWIG_As_int(obj1));
25571 if (SWIG_arg_fail(2)) SWIG_fail;
25572 }
25573 {
25574 PyThreadState* __tstate = wxPyBeginAllowThreads();
25575 {
25576 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25577 result = (wxDateSpan *) &_result_ref;
25578 }
25579
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25591 PyObject *resultobj;
25592 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25593 int arg2 ;
25594 wxDateSpan *result;
25595 PyObject * obj0 = 0 ;
25596 PyObject * obj1 = 0 ;
25597 char *kwnames[] = {
25598 (char *) "self",(char *) "n", NULL
25599 };
25600
25601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25603 if (SWIG_arg_fail(1)) SWIG_fail;
25604 {
25605 arg2 = (int)(SWIG_As_int(obj1));
25606 if (SWIG_arg_fail(2)) SWIG_fail;
25607 }
25608 {
25609 PyThreadState* __tstate = wxPyBeginAllowThreads();
25610 {
25611 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25612 result = (wxDateSpan *) &_result_ref;
25613 }
25614
25615 wxPyEndAllowThreads(__tstate);
25616 if (PyErr_Occurred()) SWIG_fail;
25617 }
25618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25626 PyObject *resultobj;
25627 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25628 int arg2 ;
25629 wxDateSpan *result;
25630 PyObject * obj0 = 0 ;
25631 PyObject * obj1 = 0 ;
25632 char *kwnames[] = {
25633 (char *) "self",(char *) "n", NULL
25634 };
25635
25636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25638 if (SWIG_arg_fail(1)) SWIG_fail;
25639 {
25640 arg2 = (int)(SWIG_As_int(obj1));
25641 if (SWIG_arg_fail(2)) SWIG_fail;
25642 }
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 {
25646 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25647 result = (wxDateSpan *) &_result_ref;
25648 }
25649
25650 wxPyEndAllowThreads(__tstate);
25651 if (PyErr_Occurred()) SWIG_fail;
25652 }
25653 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj;
25662 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25663 int result;
25664 PyObject * obj0 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (int)((wxDateSpan const *)arg1)->GetYears();
25675
25676 wxPyEndAllowThreads(__tstate);
25677 if (PyErr_Occurred()) SWIG_fail;
25678 }
25679 {
25680 resultobj = SWIG_From_int((int)(result));
25681 }
25682 return resultobj;
25683 fail:
25684 return NULL;
25685 }
25686
25687
25688 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25689 PyObject *resultobj;
25690 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25691 int result;
25692 PyObject * obj0 = 0 ;
25693 char *kwnames[] = {
25694 (char *) "self", NULL
25695 };
25696
25697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25699 if (SWIG_arg_fail(1)) SWIG_fail;
25700 {
25701 PyThreadState* __tstate = wxPyBeginAllowThreads();
25702 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25703
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 {
25708 resultobj = SWIG_From_int((int)(result));
25709 }
25710 return resultobj;
25711 fail:
25712 return NULL;
25713 }
25714
25715
25716 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25717 PyObject *resultobj;
25718 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25719 int result;
25720 PyObject * obj0 = 0 ;
25721 char *kwnames[] = {
25722 (char *) "self", NULL
25723 };
25724
25725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25727 if (SWIG_arg_fail(1)) SWIG_fail;
25728 {
25729 PyThreadState* __tstate = wxPyBeginAllowThreads();
25730 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25731
25732 wxPyEndAllowThreads(__tstate);
25733 if (PyErr_Occurred()) SWIG_fail;
25734 }
25735 {
25736 resultobj = SWIG_From_int((int)(result));
25737 }
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25745 PyObject *resultobj;
25746 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25747 int result;
25748 PyObject * obj0 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 PyThreadState* __tstate = wxPyBeginAllowThreads();
25758 result = (int)((wxDateSpan const *)arg1)->GetDays();
25759
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 {
25764 resultobj = SWIG_From_int((int)(result));
25765 }
25766 return resultobj;
25767 fail:
25768 return NULL;
25769 }
25770
25771
25772 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25773 PyObject *resultobj;
25774 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25775 int result;
25776 PyObject * obj0 = 0 ;
25777 char *kwnames[] = {
25778 (char *) "self", NULL
25779 };
25780
25781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25783 if (SWIG_arg_fail(1)) SWIG_fail;
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25787
25788 wxPyEndAllowThreads(__tstate);
25789 if (PyErr_Occurred()) SWIG_fail;
25790 }
25791 {
25792 resultobj = SWIG_From_int((int)(result));
25793 }
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25801 PyObject *resultobj;
25802 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25803 wxDateSpan *arg2 = 0 ;
25804 wxDateSpan *result;
25805 PyObject * obj0 = 0 ;
25806 PyObject * obj1 = 0 ;
25807 char *kwnames[] = {
25808 (char *) "self",(char *) "other", NULL
25809 };
25810
25811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25813 if (SWIG_arg_fail(1)) SWIG_fail;
25814 {
25815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25816 if (SWIG_arg_fail(2)) SWIG_fail;
25817 if (arg2 == NULL) {
25818 SWIG_null_ref("wxDateSpan");
25819 }
25820 if (SWIG_arg_fail(2)) SWIG_fail;
25821 }
25822 {
25823 PyThreadState* __tstate = wxPyBeginAllowThreads();
25824 {
25825 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25826 result = (wxDateSpan *) &_result_ref;
25827 }
25828
25829 wxPyEndAllowThreads(__tstate);
25830 if (PyErr_Occurred()) SWIG_fail;
25831 }
25832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25833 return resultobj;
25834 fail:
25835 return NULL;
25836 }
25837
25838
25839 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25840 PyObject *resultobj;
25841 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25842 wxDateSpan *arg2 = 0 ;
25843 wxDateSpan *result;
25844 PyObject * obj0 = 0 ;
25845 PyObject * obj1 = 0 ;
25846 char *kwnames[] = {
25847 (char *) "self",(char *) "other", NULL
25848 };
25849
25850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25852 if (SWIG_arg_fail(1)) SWIG_fail;
25853 {
25854 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25855 if (SWIG_arg_fail(2)) SWIG_fail;
25856 if (arg2 == NULL) {
25857 SWIG_null_ref("wxDateSpan");
25858 }
25859 if (SWIG_arg_fail(2)) SWIG_fail;
25860 }
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 {
25864 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
25865 result = (wxDateSpan *) &_result_ref;
25866 }
25867
25868 wxPyEndAllowThreads(__tstate);
25869 if (PyErr_Occurred()) SWIG_fail;
25870 }
25871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25872 return resultobj;
25873 fail:
25874 return NULL;
25875 }
25876
25877
25878 static PyObject *_wrap_DateSpan_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25879 PyObject *resultobj;
25880 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25881 wxDateSpan *result;
25882 PyObject * obj0 = 0 ;
25883 char *kwnames[] = {
25884 (char *) "self", NULL
25885 };
25886
25887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25889 if (SWIG_arg_fail(1)) SWIG_fail;
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 {
25893 wxDateSpan &_result_ref = (arg1)->Neg();
25894 result = (wxDateSpan *) &_result_ref;
25895 }
25896
25897 wxPyEndAllowThreads(__tstate);
25898 if (PyErr_Occurred()) SWIG_fail;
25899 }
25900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25901 return resultobj;
25902 fail:
25903 return NULL;
25904 }
25905
25906
25907 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj;
25909 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25910 int arg2 ;
25911 wxDateSpan *result;
25912 PyObject * obj0 = 0 ;
25913 PyObject * obj1 = 0 ;
25914 char *kwnames[] = {
25915 (char *) "self",(char *) "factor", NULL
25916 };
25917
25918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25920 if (SWIG_arg_fail(1)) SWIG_fail;
25921 {
25922 arg2 = (int)(SWIG_As_int(obj1));
25923 if (SWIG_arg_fail(2)) SWIG_fail;
25924 }
25925 {
25926 PyThreadState* __tstate = wxPyBeginAllowThreads();
25927 {
25928 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25929 result = (wxDateSpan *) &_result_ref;
25930 }
25931
25932 wxPyEndAllowThreads(__tstate);
25933 if (PyErr_Occurred()) SWIG_fail;
25934 }
25935 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25936 return resultobj;
25937 fail:
25938 return NULL;
25939 }
25940
25941
25942 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25943 PyObject *resultobj;
25944 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25945 wxDateSpan *arg2 = 0 ;
25946 wxDateSpan *result;
25947 PyObject * obj0 = 0 ;
25948 PyObject * obj1 = 0 ;
25949 char *kwnames[] = {
25950 (char *) "self",(char *) "other", NULL
25951 };
25952
25953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25955 if (SWIG_arg_fail(1)) SWIG_fail;
25956 {
25957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25958 if (SWIG_arg_fail(2)) SWIG_fail;
25959 if (arg2 == NULL) {
25960 SWIG_null_ref("wxDateSpan");
25961 }
25962 if (SWIG_arg_fail(2)) SWIG_fail;
25963 }
25964 {
25965 PyThreadState* __tstate = wxPyBeginAllowThreads();
25966 {
25967 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25968 result = (wxDateSpan *) &_result_ref;
25969 }
25970
25971 wxPyEndAllowThreads(__tstate);
25972 if (PyErr_Occurred()) SWIG_fail;
25973 }
25974 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25975 return resultobj;
25976 fail:
25977 return NULL;
25978 }
25979
25980
25981 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
25982 PyObject *resultobj;
25983 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25984 wxDateSpan *arg2 = 0 ;
25985 wxDateSpan *result;
25986 PyObject * obj0 = 0 ;
25987 PyObject * obj1 = 0 ;
25988 char *kwnames[] = {
25989 (char *) "self",(char *) "other", NULL
25990 };
25991
25992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
25993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25994 if (SWIG_arg_fail(1)) SWIG_fail;
25995 {
25996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25997 if (SWIG_arg_fail(2)) SWIG_fail;
25998 if (arg2 == NULL) {
25999 SWIG_null_ref("wxDateSpan");
26000 }
26001 if (SWIG_arg_fail(2)) SWIG_fail;
26002 }
26003 {
26004 PyThreadState* __tstate = wxPyBeginAllowThreads();
26005 {
26006 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
26007 result = (wxDateSpan *) &_result_ref;
26008 }
26009
26010 wxPyEndAllowThreads(__tstate);
26011 if (PyErr_Occurred()) SWIG_fail;
26012 }
26013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26014 return resultobj;
26015 fail:
26016 return NULL;
26017 }
26018
26019
26020 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26021 PyObject *resultobj;
26022 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26023 wxDateSpan *result;
26024 PyObject * obj0 = 0 ;
26025 char *kwnames[] = {
26026 (char *) "self", NULL
26027 };
26028
26029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26031 if (SWIG_arg_fail(1)) SWIG_fail;
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 {
26035 wxDateSpan &_result_ref = (arg1)->operator -();
26036 result = (wxDateSpan *) &_result_ref;
26037 }
26038
26039 wxPyEndAllowThreads(__tstate);
26040 if (PyErr_Occurred()) SWIG_fail;
26041 }
26042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj;
26051 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26052 int arg2 ;
26053 wxDateSpan *result;
26054 PyObject * obj0 = 0 ;
26055 PyObject * obj1 = 0 ;
26056 char *kwnames[] = {
26057 (char *) "self",(char *) "factor", NULL
26058 };
26059
26060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26062 if (SWIG_arg_fail(1)) SWIG_fail;
26063 {
26064 arg2 = (int)(SWIG_As_int(obj1));
26065 if (SWIG_arg_fail(2)) SWIG_fail;
26066 }
26067 {
26068 PyThreadState* __tstate = wxPyBeginAllowThreads();
26069 {
26070 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26071 result = (wxDateSpan *) &_result_ref;
26072 }
26073
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj;
26086 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26087 wxDateSpan *arg2 = 0 ;
26088 wxDateSpan result;
26089 PyObject * obj0 = 0 ;
26090 PyObject * obj1 = 0 ;
26091 char *kwnames[] = {
26092 (char *) "self",(char *) "other", NULL
26093 };
26094
26095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26097 if (SWIG_arg_fail(1)) SWIG_fail;
26098 {
26099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26100 if (SWIG_arg_fail(2)) SWIG_fail;
26101 if (arg2 == NULL) {
26102 SWIG_null_ref("wxDateSpan");
26103 }
26104 if (SWIG_arg_fail(2)) SWIG_fail;
26105 }
26106 {
26107 PyThreadState* __tstate = wxPyBeginAllowThreads();
26108 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26109
26110 wxPyEndAllowThreads(__tstate);
26111 if (PyErr_Occurred()) SWIG_fail;
26112 }
26113 {
26114 wxDateSpan * resultptr;
26115 resultptr = new wxDateSpan((wxDateSpan &)(result));
26116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26117 }
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26125 PyObject *resultobj;
26126 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26127 wxDateSpan *arg2 = 0 ;
26128 wxDateSpan result;
26129 PyObject * obj0 = 0 ;
26130 PyObject * obj1 = 0 ;
26131 char *kwnames[] = {
26132 (char *) "self",(char *) "other", NULL
26133 };
26134
26135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26137 if (SWIG_arg_fail(1)) SWIG_fail;
26138 {
26139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26140 if (SWIG_arg_fail(2)) SWIG_fail;
26141 if (arg2 == NULL) {
26142 SWIG_null_ref("wxDateSpan");
26143 }
26144 if (SWIG_arg_fail(2)) SWIG_fail;
26145 }
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26149
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 {
26154 wxDateSpan * resultptr;
26155 resultptr = new wxDateSpan((wxDateSpan &)(result));
26156 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26157 }
26158 return resultobj;
26159 fail:
26160 return NULL;
26161 }
26162
26163
26164 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26165 PyObject *resultobj;
26166 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26167 int arg2 ;
26168 wxDateSpan result;
26169 PyObject * obj0 = 0 ;
26170 PyObject * obj1 = 0 ;
26171 char *kwnames[] = {
26172 (char *) "self",(char *) "n", NULL
26173 };
26174
26175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26177 if (SWIG_arg_fail(1)) SWIG_fail;
26178 {
26179 arg2 = (int)(SWIG_As_int(obj1));
26180 if (SWIG_arg_fail(2)) SWIG_fail;
26181 }
26182 {
26183 PyThreadState* __tstate = wxPyBeginAllowThreads();
26184 result = wxDateSpan___mul__(arg1,arg2);
26185
26186 wxPyEndAllowThreads(__tstate);
26187 if (PyErr_Occurred()) SWIG_fail;
26188 }
26189 {
26190 wxDateSpan * resultptr;
26191 resultptr = new wxDateSpan((wxDateSpan &)(result));
26192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26201 PyObject *resultobj;
26202 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26203 int arg2 ;
26204 wxDateSpan result;
26205 PyObject * obj0 = 0 ;
26206 PyObject * obj1 = 0 ;
26207 char *kwnames[] = {
26208 (char *) "self",(char *) "n", NULL
26209 };
26210
26211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26213 if (SWIG_arg_fail(1)) SWIG_fail;
26214 {
26215 arg2 = (int)(SWIG_As_int(obj1));
26216 if (SWIG_arg_fail(2)) SWIG_fail;
26217 }
26218 {
26219 PyThreadState* __tstate = wxPyBeginAllowThreads();
26220 result = wxDateSpan___rmul__(arg1,arg2);
26221
26222 wxPyEndAllowThreads(__tstate);
26223 if (PyErr_Occurred()) SWIG_fail;
26224 }
26225 {
26226 wxDateSpan * resultptr;
26227 resultptr = new wxDateSpan((wxDateSpan &)(result));
26228 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26229 }
26230 return resultobj;
26231 fail:
26232 return NULL;
26233 }
26234
26235
26236 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26237 PyObject *resultobj;
26238 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26239 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26240 bool result;
26241 PyObject * obj0 = 0 ;
26242 PyObject * obj1 = 0 ;
26243 char *kwnames[] = {
26244 (char *) "self",(char *) "other", NULL
26245 };
26246
26247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26249 if (SWIG_arg_fail(1)) SWIG_fail;
26250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26251 if (SWIG_arg_fail(2)) SWIG_fail;
26252 {
26253 PyThreadState* __tstate = wxPyBeginAllowThreads();
26254 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26255
26256 wxPyEndAllowThreads(__tstate);
26257 if (PyErr_Occurred()) SWIG_fail;
26258 }
26259 {
26260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26261 }
26262 return resultobj;
26263 fail:
26264 return NULL;
26265 }
26266
26267
26268 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26269 PyObject *resultobj;
26270 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26271 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26272 bool result;
26273 PyObject * obj0 = 0 ;
26274 PyObject * obj1 = 0 ;
26275 char *kwnames[] = {
26276 (char *) "self",(char *) "other", NULL
26277 };
26278
26279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26281 if (SWIG_arg_fail(1)) SWIG_fail;
26282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26283 if (SWIG_arg_fail(2)) SWIG_fail;
26284 {
26285 PyThreadState* __tstate = wxPyBeginAllowThreads();
26286 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26287
26288 wxPyEndAllowThreads(__tstate);
26289 if (PyErr_Occurred()) SWIG_fail;
26290 }
26291 {
26292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26293 }
26294 return resultobj;
26295 fail:
26296 return NULL;
26297 }
26298
26299
26300 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26301 PyObject *obj;
26302 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26303 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26304 Py_INCREF(obj);
26305 return Py_BuildValue((char *)"");
26306 }
26307 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj;
26309 long result;
26310 char *kwnames[] = {
26311 NULL
26312 };
26313
26314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26315 {
26316 PyThreadState* __tstate = wxPyBeginAllowThreads();
26317 result = (long)wxGetLocalTime();
26318
26319 wxPyEndAllowThreads(__tstate);
26320 if (PyErr_Occurred()) SWIG_fail;
26321 }
26322 {
26323 resultobj = SWIG_From_long((long)(result));
26324 }
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26332 PyObject *resultobj;
26333 long result;
26334 char *kwnames[] = {
26335 NULL
26336 };
26337
26338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26339 {
26340 PyThreadState* __tstate = wxPyBeginAllowThreads();
26341 result = (long)wxGetUTCTime();
26342
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 {
26347 resultobj = SWIG_From_long((long)(result));
26348 }
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26356 PyObject *resultobj;
26357 long result;
26358 char *kwnames[] = {
26359 NULL
26360 };
26361
26362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = (long)wxGetCurrentTime();
26366
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 {
26371 resultobj = SWIG_From_long((long)(result));
26372 }
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj;
26381 wxLongLong result;
26382 char *kwnames[] = {
26383 NULL
26384 };
26385
26386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26387 {
26388 PyThreadState* __tstate = wxPyBeginAllowThreads();
26389 result = wxGetLocalTimeMillis();
26390
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 {
26395 PyObject *hi, *lo, *shifter, *shifted;
26396 hi = PyLong_FromLong( (&result)->GetHi() );
26397 lo = PyLong_FromLong( (&result)->GetLo() );
26398 shifter = PyLong_FromLong(32);
26399 shifted = PyNumber_Lshift(hi, shifter);
26400 resultobj = PyNumber_Or(shifted, lo);
26401 Py_DECREF(hi);
26402 Py_DECREF(lo);
26403 Py_DECREF(shifter);
26404 Py_DECREF(shifted);
26405 }
26406 return resultobj;
26407 fail:
26408 return NULL;
26409 }
26410
26411
26412 static int _wrap_DefaultDateTime_set(PyObject *) {
26413 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26414 return 1;
26415 }
26416
26417
26418 static PyObject *_wrap_DefaultDateTime_get(void) {
26419 PyObject *pyobj;
26420
26421 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26422 return pyobj;
26423 }
26424
26425
26426 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26427 PyObject *resultobj;
26428 wxDataFormatId arg1 ;
26429 wxDataFormat *result;
26430 PyObject * obj0 = 0 ;
26431 char *kwnames[] = {
26432 (char *) "type", NULL
26433 };
26434
26435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26436 {
26437 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26438 if (SWIG_arg_fail(1)) SWIG_fail;
26439 }
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26443
26444 wxPyEndAllowThreads(__tstate);
26445 if (PyErr_Occurred()) SWIG_fail;
26446 }
26447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26448 return resultobj;
26449 fail:
26450 return NULL;
26451 }
26452
26453
26454 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26455 PyObject *resultobj;
26456 wxString *arg1 = 0 ;
26457 wxDataFormat *result;
26458 bool temp1 = false ;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "format", NULL
26462 };
26463
26464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26465 {
26466 arg1 = wxString_in_helper(obj0);
26467 if (arg1 == NULL) SWIG_fail;
26468 temp1 = true;
26469 }
26470 {
26471 PyThreadState* __tstate = wxPyBeginAllowThreads();
26472 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26473
26474 wxPyEndAllowThreads(__tstate);
26475 if (PyErr_Occurred()) SWIG_fail;
26476 }
26477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26478 {
26479 if (temp1)
26480 delete arg1;
26481 }
26482 return resultobj;
26483 fail:
26484 {
26485 if (temp1)
26486 delete arg1;
26487 }
26488 return NULL;
26489 }
26490
26491
26492 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26493 PyObject *resultobj;
26494 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26495 PyObject * obj0 = 0 ;
26496 char *kwnames[] = {
26497 (char *) "self", NULL
26498 };
26499
26500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26502 if (SWIG_arg_fail(1)) SWIG_fail;
26503 {
26504 PyThreadState* __tstate = wxPyBeginAllowThreads();
26505 delete arg1;
26506
26507 wxPyEndAllowThreads(__tstate);
26508 if (PyErr_Occurred()) SWIG_fail;
26509 }
26510 Py_INCREF(Py_None); resultobj = Py_None;
26511 return resultobj;
26512 fail:
26513 return NULL;
26514 }
26515
26516
26517 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26518 PyObject *resultobj;
26519 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26520 wxDataFormatId arg2 ;
26521 bool result;
26522 PyObject * obj0 = 0 ;
26523 PyObject * obj1 = 0 ;
26524
26525 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26527 if (SWIG_arg_fail(1)) SWIG_fail;
26528 {
26529 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26530 if (SWIG_arg_fail(2)) SWIG_fail;
26531 }
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26535
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 {
26540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26541 }
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26549 PyObject *resultobj;
26550 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26551 wxDataFormatId arg2 ;
26552 bool result;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555
26556 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26558 if (SWIG_arg_fail(1)) SWIG_fail;
26559 {
26560 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26561 if (SWIG_arg_fail(2)) SWIG_fail;
26562 }
26563 {
26564 PyThreadState* __tstate = wxPyBeginAllowThreads();
26565 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26566
26567 wxPyEndAllowThreads(__tstate);
26568 if (PyErr_Occurred()) SWIG_fail;
26569 }
26570 {
26571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26572 }
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26580 PyObject *resultobj;
26581 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26582 wxDataFormat *arg2 = 0 ;
26583 bool result;
26584 PyObject * obj0 = 0 ;
26585 PyObject * obj1 = 0 ;
26586
26587 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26589 if (SWIG_arg_fail(1)) SWIG_fail;
26590 {
26591 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26592 if (SWIG_arg_fail(2)) SWIG_fail;
26593 if (arg2 == NULL) {
26594 SWIG_null_ref("wxDataFormat");
26595 }
26596 if (SWIG_arg_fail(2)) SWIG_fail;
26597 }
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26601
26602 wxPyEndAllowThreads(__tstate);
26603 if (PyErr_Occurred()) SWIG_fail;
26604 }
26605 {
26606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26607 }
26608 return resultobj;
26609 fail:
26610 return NULL;
26611 }
26612
26613
26614 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26615 int argc;
26616 PyObject *argv[3];
26617 int ii;
26618
26619 argc = PyObject_Length(args);
26620 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26621 argv[ii] = PyTuple_GetItem(args,ii);
26622 }
26623 if (argc == 2) {
26624 int _v;
26625 {
26626 void *ptr;
26627 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26628 _v = 0;
26629 PyErr_Clear();
26630 } else {
26631 _v = 1;
26632 }
26633 }
26634 if (_v) {
26635 {
26636 void *ptr = 0;
26637 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26638 _v = 0;
26639 PyErr_Clear();
26640 } else {
26641 _v = (ptr != 0);
26642 }
26643 }
26644 if (_v) {
26645 return _wrap_DataFormat___eq____SWIG_1(self,args);
26646 }
26647 }
26648 }
26649 if (argc == 2) {
26650 int _v;
26651 {
26652 void *ptr;
26653 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26654 _v = 0;
26655 PyErr_Clear();
26656 } else {
26657 _v = 1;
26658 }
26659 }
26660 if (_v) {
26661 _v = SWIG_Check_int(argv[1]);
26662 if (_v) {
26663 return _wrap_DataFormat___eq____SWIG_0(self,args);
26664 }
26665 }
26666 }
26667
26668 Py_INCREF(Py_NotImplemented);
26669 return Py_NotImplemented;
26670 }
26671
26672
26673 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26674 PyObject *resultobj;
26675 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26676 wxDataFormat *arg2 = 0 ;
26677 bool result;
26678 PyObject * obj0 = 0 ;
26679 PyObject * obj1 = 0 ;
26680
26681 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26683 if (SWIG_arg_fail(1)) SWIG_fail;
26684 {
26685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26686 if (SWIG_arg_fail(2)) SWIG_fail;
26687 if (arg2 == NULL) {
26688 SWIG_null_ref("wxDataFormat");
26689 }
26690 if (SWIG_arg_fail(2)) SWIG_fail;
26691 }
26692 {
26693 PyThreadState* __tstate = wxPyBeginAllowThreads();
26694 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26695
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 {
26700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26701 }
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26709 int argc;
26710 PyObject *argv[3];
26711 int ii;
26712
26713 argc = PyObject_Length(args);
26714 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26715 argv[ii] = PyTuple_GetItem(args,ii);
26716 }
26717 if (argc == 2) {
26718 int _v;
26719 {
26720 void *ptr;
26721 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26722 _v = 0;
26723 PyErr_Clear();
26724 } else {
26725 _v = 1;
26726 }
26727 }
26728 if (_v) {
26729 {
26730 void *ptr = 0;
26731 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26732 _v = 0;
26733 PyErr_Clear();
26734 } else {
26735 _v = (ptr != 0);
26736 }
26737 }
26738 if (_v) {
26739 return _wrap_DataFormat___ne____SWIG_1(self,args);
26740 }
26741 }
26742 }
26743 if (argc == 2) {
26744 int _v;
26745 {
26746 void *ptr;
26747 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26748 _v = 0;
26749 PyErr_Clear();
26750 } else {
26751 _v = 1;
26752 }
26753 }
26754 if (_v) {
26755 _v = SWIG_Check_int(argv[1]);
26756 if (_v) {
26757 return _wrap_DataFormat___ne____SWIG_0(self,args);
26758 }
26759 }
26760 }
26761
26762 Py_INCREF(Py_NotImplemented);
26763 return Py_NotImplemented;
26764 }
26765
26766
26767 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26768 PyObject *resultobj;
26769 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26770 wxDataFormatId arg2 ;
26771 PyObject * obj0 = 0 ;
26772 PyObject * obj1 = 0 ;
26773 char *kwnames[] = {
26774 (char *) "self",(char *) "format", NULL
26775 };
26776
26777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26779 if (SWIG_arg_fail(1)) SWIG_fail;
26780 {
26781 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26782 if (SWIG_arg_fail(2)) SWIG_fail;
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 (arg1)->SetType((wxDataFormatId )arg2);
26787
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 Py_INCREF(Py_None); resultobj = Py_None;
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26799 PyObject *resultobj;
26800 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26801 wxDataFormatId result;
26802 PyObject * obj0 = 0 ;
26803 char *kwnames[] = {
26804 (char *) "self", NULL
26805 };
26806
26807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26809 if (SWIG_arg_fail(1)) SWIG_fail;
26810 {
26811 PyThreadState* __tstate = wxPyBeginAllowThreads();
26812 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26813
26814 wxPyEndAllowThreads(__tstate);
26815 if (PyErr_Occurred()) SWIG_fail;
26816 }
26817 resultobj = SWIG_From_int((result));
26818 return resultobj;
26819 fail:
26820 return NULL;
26821 }
26822
26823
26824 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26825 PyObject *resultobj;
26826 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26827 wxString result;
26828 PyObject * obj0 = 0 ;
26829 char *kwnames[] = {
26830 (char *) "self", NULL
26831 };
26832
26833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26835 if (SWIG_arg_fail(1)) SWIG_fail;
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 result = ((wxDataFormat const *)arg1)->GetId();
26839
26840 wxPyEndAllowThreads(__tstate);
26841 if (PyErr_Occurred()) SWIG_fail;
26842 }
26843 {
26844 #if wxUSE_UNICODE
26845 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26846 #else
26847 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26848 #endif
26849 }
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26857 PyObject *resultobj;
26858 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26859 wxString *arg2 = 0 ;
26860 bool temp2 = false ;
26861 PyObject * obj0 = 0 ;
26862 PyObject * obj1 = 0 ;
26863 char *kwnames[] = {
26864 (char *) "self",(char *) "format", NULL
26865 };
26866
26867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26869 if (SWIG_arg_fail(1)) SWIG_fail;
26870 {
26871 arg2 = wxString_in_helper(obj1);
26872 if (arg2 == NULL) SWIG_fail;
26873 temp2 = true;
26874 }
26875 {
26876 PyThreadState* __tstate = wxPyBeginAllowThreads();
26877 (arg1)->SetId((wxString const &)*arg2);
26878
26879 wxPyEndAllowThreads(__tstate);
26880 if (PyErr_Occurred()) SWIG_fail;
26881 }
26882 Py_INCREF(Py_None); resultobj = Py_None;
26883 {
26884 if (temp2)
26885 delete arg2;
26886 }
26887 return resultobj;
26888 fail:
26889 {
26890 if (temp2)
26891 delete arg2;
26892 }
26893 return NULL;
26894 }
26895
26896
26897 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26898 PyObject *obj;
26899 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26900 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26901 Py_INCREF(obj);
26902 return Py_BuildValue((char *)"");
26903 }
26904 static int _wrap_FormatInvalid_set(PyObject *) {
26905 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26906 return 1;
26907 }
26908
26909
26910 static PyObject *_wrap_FormatInvalid_get(void) {
26911 PyObject *pyobj;
26912
26913 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26914 return pyobj;
26915 }
26916
26917
26918 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj;
26920 wxDataObject *arg1 = (wxDataObject *) 0 ;
26921 PyObject * obj0 = 0 ;
26922 char *kwnames[] = {
26923 (char *) "self", NULL
26924 };
26925
26926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26928 if (SWIG_arg_fail(1)) SWIG_fail;
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 delete arg1;
26932
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 Py_INCREF(Py_None); resultobj = Py_None;
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj;
26945 wxDataObject *arg1 = (wxDataObject *) 0 ;
26946 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26947 SwigValueWrapper<wxDataFormat > result;
26948 PyObject * obj0 = 0 ;
26949 PyObject * obj1 = 0 ;
26950 char *kwnames[] = {
26951 (char *) "self",(char *) "dir", NULL
26952 };
26953
26954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26956 if (SWIG_arg_fail(1)) SWIG_fail;
26957 if (obj1) {
26958 {
26959 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26960 if (SWIG_arg_fail(2)) SWIG_fail;
26961 }
26962 }
26963 {
26964 PyThreadState* __tstate = wxPyBeginAllowThreads();
26965 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26966
26967 wxPyEndAllowThreads(__tstate);
26968 if (PyErr_Occurred()) SWIG_fail;
26969 }
26970 {
26971 wxDataFormat * resultptr;
26972 resultptr = new wxDataFormat((wxDataFormat &)(result));
26973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
26974 }
26975 return resultobj;
26976 fail:
26977 return NULL;
26978 }
26979
26980
26981 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
26982 PyObject *resultobj;
26983 wxDataObject *arg1 = (wxDataObject *) 0 ;
26984 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26985 size_t result;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char *kwnames[] = {
26989 (char *) "self",(char *) "dir", NULL
26990 };
26991
26992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
26993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26994 if (SWIG_arg_fail(1)) SWIG_fail;
26995 if (obj1) {
26996 {
26997 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26998 if (SWIG_arg_fail(2)) SWIG_fail;
26999 }
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27004
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 {
27009 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27010 }
27011 return resultobj;
27012 fail:
27013 return NULL;
27014 }
27015
27016
27017 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27018 PyObject *resultobj;
27019 wxDataObject *arg1 = (wxDataObject *) 0 ;
27020 wxDataFormat *arg2 = 0 ;
27021 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27022 bool result;
27023 PyObject * obj0 = 0 ;
27024 PyObject * obj1 = 0 ;
27025 PyObject * obj2 = 0 ;
27026 char *kwnames[] = {
27027 (char *) "self",(char *) "format",(char *) "dir", NULL
27028 };
27029
27030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27032 if (SWIG_arg_fail(1)) SWIG_fail;
27033 {
27034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27035 if (SWIG_arg_fail(2)) SWIG_fail;
27036 if (arg2 == NULL) {
27037 SWIG_null_ref("wxDataFormat");
27038 }
27039 if (SWIG_arg_fail(2)) SWIG_fail;
27040 }
27041 if (obj2) {
27042 {
27043 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27044 if (SWIG_arg_fail(3)) SWIG_fail;
27045 }
27046 }
27047 {
27048 PyThreadState* __tstate = wxPyBeginAllowThreads();
27049 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27050
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 {
27055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27056 }
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27064 PyObject *resultobj;
27065 wxDataObject *arg1 = (wxDataObject *) 0 ;
27066 wxDataFormat *arg2 = 0 ;
27067 size_t result;
27068 PyObject * obj0 = 0 ;
27069 PyObject * obj1 = 0 ;
27070 char *kwnames[] = {
27071 (char *) "self",(char *) "format", NULL
27072 };
27073
27074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27076 if (SWIG_arg_fail(1)) SWIG_fail;
27077 {
27078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27079 if (SWIG_arg_fail(2)) SWIG_fail;
27080 if (arg2 == NULL) {
27081 SWIG_null_ref("wxDataFormat");
27082 }
27083 if (SWIG_arg_fail(2)) SWIG_fail;
27084 }
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27088
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 {
27093 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27094 }
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27102 PyObject *resultobj;
27103 wxDataObject *arg1 = (wxDataObject *) 0 ;
27104 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27105 PyObject *result;
27106 PyObject * obj0 = 0 ;
27107 PyObject * obj1 = 0 ;
27108 char *kwnames[] = {
27109 (char *) "self",(char *) "dir", NULL
27110 };
27111
27112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27114 if (SWIG_arg_fail(1)) SWIG_fail;
27115 if (obj1) {
27116 {
27117 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27118 if (SWIG_arg_fail(2)) SWIG_fail;
27119 }
27120 }
27121 {
27122 PyThreadState* __tstate = wxPyBeginAllowThreads();
27123 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27124
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 resultobj = result;
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27136 PyObject *resultobj;
27137 wxDataObject *arg1 = (wxDataObject *) 0 ;
27138 wxDataFormat *arg2 = 0 ;
27139 PyObject *result;
27140 PyObject * obj0 = 0 ;
27141 PyObject * obj1 = 0 ;
27142 char *kwnames[] = {
27143 (char *) "self",(char *) "format", NULL
27144 };
27145
27146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27148 if (SWIG_arg_fail(1)) SWIG_fail;
27149 {
27150 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27151 if (SWIG_arg_fail(2)) SWIG_fail;
27152 if (arg2 == NULL) {
27153 SWIG_null_ref("wxDataFormat");
27154 }
27155 if (SWIG_arg_fail(2)) SWIG_fail;
27156 }
27157 {
27158 PyThreadState* __tstate = wxPyBeginAllowThreads();
27159 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27160
27161 wxPyEndAllowThreads(__tstate);
27162 if (PyErr_Occurred()) SWIG_fail;
27163 }
27164 resultobj = result;
27165 return resultobj;
27166 fail:
27167 return NULL;
27168 }
27169
27170
27171 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27172 PyObject *resultobj;
27173 wxDataObject *arg1 = (wxDataObject *) 0 ;
27174 wxDataFormat *arg2 = 0 ;
27175 PyObject *arg3 = (PyObject *) 0 ;
27176 bool result;
27177 PyObject * obj0 = 0 ;
27178 PyObject * obj1 = 0 ;
27179 PyObject * obj2 = 0 ;
27180 char *kwnames[] = {
27181 (char *) "self",(char *) "format",(char *) "data", NULL
27182 };
27183
27184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27186 if (SWIG_arg_fail(1)) SWIG_fail;
27187 {
27188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27189 if (SWIG_arg_fail(2)) SWIG_fail;
27190 if (arg2 == NULL) {
27191 SWIG_null_ref("wxDataFormat");
27192 }
27193 if (SWIG_arg_fail(2)) SWIG_fail;
27194 }
27195 arg3 = obj2;
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27213 PyObject *obj;
27214 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27215 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27216 Py_INCREF(obj);
27217 return Py_BuildValue((char *)"");
27218 }
27219 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27220 PyObject *resultobj;
27221 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27222 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27223 wxDataObjectSimple *result;
27224 PyObject * obj0 = 0 ;
27225 char *kwnames[] = {
27226 (char *) "format", NULL
27227 };
27228
27229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27230 if (obj0) {
27231 {
27232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27233 if (SWIG_arg_fail(1)) SWIG_fail;
27234 if (arg1 == NULL) {
27235 SWIG_null_ref("wxDataFormat");
27236 }
27237 if (SWIG_arg_fail(1)) SWIG_fail;
27238 }
27239 }
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27243
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27248 return resultobj;
27249 fail:
27250 return NULL;
27251 }
27252
27253
27254 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27255 PyObject *resultobj;
27256 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27257 wxDataFormat *result;
27258 PyObject * obj0 = 0 ;
27259 char *kwnames[] = {
27260 (char *) "self", NULL
27261 };
27262
27263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27265 if (SWIG_arg_fail(1)) SWIG_fail;
27266 {
27267 PyThreadState* __tstate = wxPyBeginAllowThreads();
27268 {
27269 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27270 result = (wxDataFormat *) &_result_ref;
27271 }
27272
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27286 wxDataFormat *arg2 = 0 ;
27287 PyObject * obj0 = 0 ;
27288 PyObject * obj1 = 0 ;
27289 char *kwnames[] = {
27290 (char *) "self",(char *) "format", NULL
27291 };
27292
27293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27295 if (SWIG_arg_fail(1)) SWIG_fail;
27296 {
27297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(2)) SWIG_fail;
27299 if (arg2 == NULL) {
27300 SWIG_null_ref("wxDataFormat");
27301 }
27302 if (SWIG_arg_fail(2)) SWIG_fail;
27303 }
27304 {
27305 PyThreadState* __tstate = wxPyBeginAllowThreads();
27306 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27307
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 Py_INCREF(Py_None); resultobj = Py_None;
27312 return resultobj;
27313 fail:
27314 return NULL;
27315 }
27316
27317
27318 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj;
27320 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27321 size_t result;
27322 PyObject * obj0 = 0 ;
27323 char *kwnames[] = {
27324 (char *) "self", NULL
27325 };
27326
27327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27329 if (SWIG_arg_fail(1)) SWIG_fail;
27330 {
27331 PyThreadState* __tstate = wxPyBeginAllowThreads();
27332 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27333
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27339 }
27340 return resultobj;
27341 fail:
27342 return NULL;
27343 }
27344
27345
27346 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27347 PyObject *resultobj;
27348 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27349 PyObject *result;
27350 PyObject * obj0 = 0 ;
27351 char *kwnames[] = {
27352 (char *) "self", NULL
27353 };
27354
27355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27357 if (SWIG_arg_fail(1)) SWIG_fail;
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27361
27362 wxPyEndAllowThreads(__tstate);
27363 if (PyErr_Occurred()) SWIG_fail;
27364 }
27365 resultobj = result;
27366 return resultobj;
27367 fail:
27368 return NULL;
27369 }
27370
27371
27372 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27373 PyObject *resultobj;
27374 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27375 PyObject *arg2 = (PyObject *) 0 ;
27376 bool result;
27377 PyObject * obj0 = 0 ;
27378 PyObject * obj1 = 0 ;
27379 char *kwnames[] = {
27380 (char *) "self",(char *) "data", NULL
27381 };
27382
27383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27385 if (SWIG_arg_fail(1)) SWIG_fail;
27386 arg2 = obj1;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 {
27395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27396 }
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27404 PyObject *obj;
27405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27406 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27407 Py_INCREF(obj);
27408 return Py_BuildValue((char *)"");
27409 }
27410 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27411 PyObject *resultobj;
27412 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27413 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27414 wxPyDataObjectSimple *result;
27415 PyObject * obj0 = 0 ;
27416 char *kwnames[] = {
27417 (char *) "format", NULL
27418 };
27419
27420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27421 if (obj0) {
27422 {
27423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27424 if (SWIG_arg_fail(1)) SWIG_fail;
27425 if (arg1 == NULL) {
27426 SWIG_null_ref("wxDataFormat");
27427 }
27428 if (SWIG_arg_fail(1)) SWIG_fail;
27429 }
27430 }
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27434
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27446 PyObject *resultobj;
27447 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27448 PyObject *arg2 = (PyObject *) 0 ;
27449 PyObject *arg3 = (PyObject *) 0 ;
27450 PyObject * obj0 = 0 ;
27451 PyObject * obj1 = 0 ;
27452 PyObject * obj2 = 0 ;
27453 char *kwnames[] = {
27454 (char *) "self",(char *) "self",(char *) "_class", NULL
27455 };
27456
27457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27459 if (SWIG_arg_fail(1)) SWIG_fail;
27460 arg2 = obj1;
27461 arg3 = obj2;
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 (arg1)->_setCallbackInfo(arg2,arg3);
27465
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 Py_INCREF(Py_None); resultobj = Py_None;
27470 return resultobj;
27471 fail:
27472 return NULL;
27473 }
27474
27475
27476 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27477 PyObject *obj;
27478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27479 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27480 Py_INCREF(obj);
27481 return Py_BuildValue((char *)"");
27482 }
27483 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27484 PyObject *resultobj;
27485 wxDataObjectComposite *result;
27486 char *kwnames[] = {
27487 NULL
27488 };
27489
27490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27491 {
27492 PyThreadState* __tstate = wxPyBeginAllowThreads();
27493 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27494
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27506 PyObject *resultobj;
27507 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27508 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27509 bool arg3 = (bool) false ;
27510 PyObject * obj0 = 0 ;
27511 PyObject * obj1 = 0 ;
27512 PyObject * obj2 = 0 ;
27513 char *kwnames[] = {
27514 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27515 };
27516
27517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27519 if (SWIG_arg_fail(1)) SWIG_fail;
27520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27521 if (SWIG_arg_fail(2)) SWIG_fail;
27522 if (obj2) {
27523 {
27524 arg3 = (bool)(SWIG_As_bool(obj2));
27525 if (SWIG_arg_fail(3)) SWIG_fail;
27526 }
27527 }
27528 {
27529 PyThreadState* __tstate = wxPyBeginAllowThreads();
27530 (arg1)->Add(arg2,arg3);
27531
27532 wxPyEndAllowThreads(__tstate);
27533 if (PyErr_Occurred()) SWIG_fail;
27534 }
27535 Py_INCREF(Py_None); resultobj = Py_None;
27536 return resultobj;
27537 fail:
27538 return NULL;
27539 }
27540
27541
27542 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27543 PyObject *obj;
27544 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27545 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27546 Py_INCREF(obj);
27547 return Py_BuildValue((char *)"");
27548 }
27549 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj;
27551 wxString const &arg1_defvalue = wxPyEmptyString ;
27552 wxString *arg1 = (wxString *) &arg1_defvalue ;
27553 wxTextDataObject *result;
27554 bool temp1 = false ;
27555 PyObject * obj0 = 0 ;
27556 char *kwnames[] = {
27557 (char *) "text", NULL
27558 };
27559
27560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27561 if (obj0) {
27562 {
27563 arg1 = wxString_in_helper(obj0);
27564 if (arg1 == NULL) SWIG_fail;
27565 temp1 = true;
27566 }
27567 }
27568 {
27569 PyThreadState* __tstate = wxPyBeginAllowThreads();
27570 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27571
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27576 {
27577 if (temp1)
27578 delete arg1;
27579 }
27580 return resultobj;
27581 fail:
27582 {
27583 if (temp1)
27584 delete arg1;
27585 }
27586 return NULL;
27587 }
27588
27589
27590 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27591 PyObject *resultobj;
27592 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27593 size_t result;
27594 PyObject * obj0 = 0 ;
27595 char *kwnames[] = {
27596 (char *) "self", NULL
27597 };
27598
27599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27601 if (SWIG_arg_fail(1)) SWIG_fail;
27602 {
27603 PyThreadState* __tstate = wxPyBeginAllowThreads();
27604 result = (size_t)(arg1)->GetTextLength();
27605
27606 wxPyEndAllowThreads(__tstate);
27607 if (PyErr_Occurred()) SWIG_fail;
27608 }
27609 {
27610 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27611 }
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27619 PyObject *resultobj;
27620 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27621 wxString result;
27622 PyObject * obj0 = 0 ;
27623 char *kwnames[] = {
27624 (char *) "self", NULL
27625 };
27626
27627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27629 if (SWIG_arg_fail(1)) SWIG_fail;
27630 {
27631 PyThreadState* __tstate = wxPyBeginAllowThreads();
27632 result = (arg1)->GetText();
27633
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 {
27638 #if wxUSE_UNICODE
27639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27640 #else
27641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27642 #endif
27643 }
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj;
27652 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27653 wxString *arg2 = 0 ;
27654 bool temp2 = false ;
27655 PyObject * obj0 = 0 ;
27656 PyObject * obj1 = 0 ;
27657 char *kwnames[] = {
27658 (char *) "self",(char *) "text", NULL
27659 };
27660
27661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27663 if (SWIG_arg_fail(1)) SWIG_fail;
27664 {
27665 arg2 = wxString_in_helper(obj1);
27666 if (arg2 == NULL) SWIG_fail;
27667 temp2 = true;
27668 }
27669 {
27670 PyThreadState* __tstate = wxPyBeginAllowThreads();
27671 (arg1)->SetText((wxString const &)*arg2);
27672
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 Py_INCREF(Py_None); resultobj = Py_None;
27677 {
27678 if (temp2)
27679 delete arg2;
27680 }
27681 return resultobj;
27682 fail:
27683 {
27684 if (temp2)
27685 delete arg2;
27686 }
27687 return NULL;
27688 }
27689
27690
27691 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27692 PyObject *obj;
27693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27694 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27695 Py_INCREF(obj);
27696 return Py_BuildValue((char *)"");
27697 }
27698 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxString const &arg1_defvalue = wxPyEmptyString ;
27701 wxString *arg1 = (wxString *) &arg1_defvalue ;
27702 wxPyTextDataObject *result;
27703 bool temp1 = false ;
27704 PyObject * obj0 = 0 ;
27705 char *kwnames[] = {
27706 (char *) "text", NULL
27707 };
27708
27709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27710 if (obj0) {
27711 {
27712 arg1 = wxString_in_helper(obj0);
27713 if (arg1 == NULL) SWIG_fail;
27714 temp1 = true;
27715 }
27716 }
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27720
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27725 {
27726 if (temp1)
27727 delete arg1;
27728 }
27729 return resultobj;
27730 fail:
27731 {
27732 if (temp1)
27733 delete arg1;
27734 }
27735 return NULL;
27736 }
27737
27738
27739 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27740 PyObject *resultobj;
27741 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27742 PyObject *arg2 = (PyObject *) 0 ;
27743 PyObject *arg3 = (PyObject *) 0 ;
27744 PyObject * obj0 = 0 ;
27745 PyObject * obj1 = 0 ;
27746 PyObject * obj2 = 0 ;
27747 char *kwnames[] = {
27748 (char *) "self",(char *) "self",(char *) "_class", NULL
27749 };
27750
27751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27753 if (SWIG_arg_fail(1)) SWIG_fail;
27754 arg2 = obj1;
27755 arg3 = obj2;
27756 {
27757 PyThreadState* __tstate = wxPyBeginAllowThreads();
27758 (arg1)->_setCallbackInfo(arg2,arg3);
27759
27760 wxPyEndAllowThreads(__tstate);
27761 if (PyErr_Occurred()) SWIG_fail;
27762 }
27763 Py_INCREF(Py_None); resultobj = Py_None;
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27771 PyObject *obj;
27772 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27773 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27774 Py_INCREF(obj);
27775 return Py_BuildValue((char *)"");
27776 }
27777 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27778 PyObject *resultobj;
27779 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27780 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27781 wxBitmapDataObject *result;
27782 PyObject * obj0 = 0 ;
27783 char *kwnames[] = {
27784 (char *) "bitmap", NULL
27785 };
27786
27787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27788 if (obj0) {
27789 {
27790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27791 if (SWIG_arg_fail(1)) SWIG_fail;
27792 if (arg1 == NULL) {
27793 SWIG_null_ref("wxBitmap");
27794 }
27795 if (SWIG_arg_fail(1)) SWIG_fail;
27796 }
27797 }
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27801
27802 wxPyEndAllowThreads(__tstate);
27803 if (PyErr_Occurred()) SWIG_fail;
27804 }
27805 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27813 PyObject *resultobj;
27814 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27815 wxBitmap result;
27816 PyObject * obj0 = 0 ;
27817 char *kwnames[] = {
27818 (char *) "self", NULL
27819 };
27820
27821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27823 if (SWIG_arg_fail(1)) SWIG_fail;
27824 {
27825 PyThreadState* __tstate = wxPyBeginAllowThreads();
27826 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27827
27828 wxPyEndAllowThreads(__tstate);
27829 if (PyErr_Occurred()) SWIG_fail;
27830 }
27831 {
27832 wxBitmap * resultptr;
27833 resultptr = new wxBitmap((wxBitmap &)(result));
27834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27835 }
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27843 PyObject *resultobj;
27844 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27845 wxBitmap *arg2 = 0 ;
27846 PyObject * obj0 = 0 ;
27847 PyObject * obj1 = 0 ;
27848 char *kwnames[] = {
27849 (char *) "self",(char *) "bitmap", NULL
27850 };
27851
27852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27854 if (SWIG_arg_fail(1)) SWIG_fail;
27855 {
27856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27857 if (SWIG_arg_fail(2)) SWIG_fail;
27858 if (arg2 == NULL) {
27859 SWIG_null_ref("wxBitmap");
27860 }
27861 if (SWIG_arg_fail(2)) SWIG_fail;
27862 }
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27866
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 Py_INCREF(Py_None); resultobj = Py_None;
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27878 PyObject *obj;
27879 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27880 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27881 Py_INCREF(obj);
27882 return Py_BuildValue((char *)"");
27883 }
27884 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27885 PyObject *resultobj;
27886 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27887 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27888 wxPyBitmapDataObject *result;
27889 PyObject * obj0 = 0 ;
27890 char *kwnames[] = {
27891 (char *) "bitmap", NULL
27892 };
27893
27894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27895 if (obj0) {
27896 {
27897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27898 if (SWIG_arg_fail(1)) SWIG_fail;
27899 if (arg1 == NULL) {
27900 SWIG_null_ref("wxBitmap");
27901 }
27902 if (SWIG_arg_fail(1)) SWIG_fail;
27903 }
27904 }
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27913 return resultobj;
27914 fail:
27915 return NULL;
27916 }
27917
27918
27919 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27920 PyObject *resultobj;
27921 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27922 PyObject *arg2 = (PyObject *) 0 ;
27923 PyObject *arg3 = (PyObject *) 0 ;
27924 PyObject * obj0 = 0 ;
27925 PyObject * obj1 = 0 ;
27926 PyObject * obj2 = 0 ;
27927 char *kwnames[] = {
27928 (char *) "self",(char *) "self",(char *) "_class", NULL
27929 };
27930
27931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27933 if (SWIG_arg_fail(1)) SWIG_fail;
27934 arg2 = obj1;
27935 arg3 = obj2;
27936 {
27937 PyThreadState* __tstate = wxPyBeginAllowThreads();
27938 (arg1)->_setCallbackInfo(arg2,arg3);
27939
27940 wxPyEndAllowThreads(__tstate);
27941 if (PyErr_Occurred()) SWIG_fail;
27942 }
27943 Py_INCREF(Py_None); resultobj = Py_None;
27944 return resultobj;
27945 fail:
27946 return NULL;
27947 }
27948
27949
27950 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27951 PyObject *obj;
27952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27953 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27954 Py_INCREF(obj);
27955 return Py_BuildValue((char *)"");
27956 }
27957 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27958 PyObject *resultobj;
27959 wxFileDataObject *result;
27960 char *kwnames[] = {
27961 NULL
27962 };
27963
27964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (wxFileDataObject *)new wxFileDataObject();
27968
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
27980 PyObject *resultobj;
27981 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
27982 wxArrayString *result;
27983 PyObject * obj0 = 0 ;
27984 char *kwnames[] = {
27985 (char *) "self", NULL
27986 };
27987
27988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
27989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
27990 if (SWIG_arg_fail(1)) SWIG_fail;
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 {
27994 wxArrayString const &_result_ref = (arg1)->GetFilenames();
27995 result = (wxArrayString *) &_result_ref;
27996 }
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 {
28002 resultobj = wxArrayString2PyList_helper(*result);
28003 }
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28013 wxString *arg2 = 0 ;
28014 bool temp2 = false ;
28015 PyObject * obj0 = 0 ;
28016 PyObject * obj1 = 0 ;
28017 char *kwnames[] = {
28018 (char *) "self",(char *) "filename", NULL
28019 };
28020
28021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(1)) SWIG_fail;
28024 {
28025 arg2 = wxString_in_helper(obj1);
28026 if (arg2 == NULL) SWIG_fail;
28027 temp2 = true;
28028 }
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 (arg1)->AddFile((wxString const &)*arg2);
28032
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 Py_INCREF(Py_None); resultobj = Py_None;
28037 {
28038 if (temp2)
28039 delete arg2;
28040 }
28041 return resultobj;
28042 fail:
28043 {
28044 if (temp2)
28045 delete arg2;
28046 }
28047 return NULL;
28048 }
28049
28050
28051 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28052 PyObject *obj;
28053 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28054 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28055 Py_INCREF(obj);
28056 return Py_BuildValue((char *)"");
28057 }
28058 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28059 PyObject *resultobj;
28060 wxDataFormat *arg1 = 0 ;
28061 wxCustomDataObject *result;
28062 PyObject * obj0 = 0 ;
28063
28064 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28065 {
28066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28067 if (SWIG_arg_fail(1)) SWIG_fail;
28068 if (arg1 == NULL) {
28069 SWIG_null_ref("wxDataFormat");
28070 }
28071 if (SWIG_arg_fail(1)) SWIG_fail;
28072 }
28073 {
28074 PyThreadState* __tstate = wxPyBeginAllowThreads();
28075 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28076
28077 wxPyEndAllowThreads(__tstate);
28078 if (PyErr_Occurred()) SWIG_fail;
28079 }
28080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28081 return resultobj;
28082 fail:
28083 return NULL;
28084 }
28085
28086
28087 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28088 PyObject *resultobj;
28089 wxString *arg1 = 0 ;
28090 wxCustomDataObject *result;
28091 bool temp1 = false ;
28092 PyObject * obj0 = 0 ;
28093
28094 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28095 {
28096 arg1 = wxString_in_helper(obj0);
28097 if (arg1 == NULL) SWIG_fail;
28098 temp1 = true;
28099 }
28100 {
28101 PyThreadState* __tstate = wxPyBeginAllowThreads();
28102 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28103
28104 wxPyEndAllowThreads(__tstate);
28105 if (PyErr_Occurred()) SWIG_fail;
28106 }
28107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28108 {
28109 if (temp1)
28110 delete arg1;
28111 }
28112 return resultobj;
28113 fail:
28114 {
28115 if (temp1)
28116 delete arg1;
28117 }
28118 return NULL;
28119 }
28120
28121
28122 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28123 PyObject *resultobj;
28124 wxCustomDataObject *result;
28125
28126 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28127 {
28128 PyThreadState* __tstate = wxPyBeginAllowThreads();
28129 result = (wxCustomDataObject *)new wxCustomDataObject();
28130
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28135 return resultobj;
28136 fail:
28137 return NULL;
28138 }
28139
28140
28141 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28142 int argc;
28143 PyObject *argv[2];
28144 int ii;
28145
28146 argc = PyObject_Length(args);
28147 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28148 argv[ii] = PyTuple_GetItem(args,ii);
28149 }
28150 if (argc == 0) {
28151 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28152 }
28153 if (argc == 1) {
28154 int _v;
28155 {
28156 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28157 }
28158 if (_v) {
28159 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28160 }
28161 }
28162 if (argc == 1) {
28163 int _v;
28164 {
28165 void *ptr = 0;
28166 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28167 _v = 0;
28168 PyErr_Clear();
28169 } else {
28170 _v = (ptr != 0);
28171 }
28172 }
28173 if (_v) {
28174 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28175 }
28176 }
28177
28178 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28179 return NULL;
28180 }
28181
28182
28183 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28184 PyObject *resultobj;
28185 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28186 PyObject *arg2 = (PyObject *) 0 ;
28187 bool result;
28188 PyObject * obj0 = 0 ;
28189 PyObject * obj1 = 0 ;
28190 char *kwnames[] = {
28191 (char *) "self",(char *) "data", NULL
28192 };
28193
28194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) goto fail;
28195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28196 if (SWIG_arg_fail(1)) SWIG_fail;
28197 arg2 = obj1;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 {
28206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28207 }
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28217 size_t result;
28218 PyObject * obj0 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self", NULL
28221 };
28222
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28225 if (SWIG_arg_fail(1)) SWIG_fail;
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (size_t)(arg1)->GetSize();
28229
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 {
28234 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28235 }
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj;
28244 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28245 PyObject *result;
28246 PyObject * obj0 = 0 ;
28247 char *kwnames[] = {
28248 (char *) "self", NULL
28249 };
28250
28251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28253 if (SWIG_arg_fail(1)) SWIG_fail;
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28257
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 resultobj = result;
28262 return resultobj;
28263 fail:
28264 return NULL;
28265 }
28266
28267
28268 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28269 PyObject *obj;
28270 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28271 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28272 Py_INCREF(obj);
28273 return Py_BuildValue((char *)"");
28274 }
28275 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj;
28277 wxURLDataObject *result;
28278 char *kwnames[] = {
28279 NULL
28280 };
28281
28282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (wxURLDataObject *)new wxURLDataObject();
28286
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28298 PyObject *resultobj;
28299 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28300 wxString result;
28301 PyObject * obj0 = 0 ;
28302 char *kwnames[] = {
28303 (char *) "self", NULL
28304 };
28305
28306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28308 if (SWIG_arg_fail(1)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (arg1)->GetURL();
28312
28313 wxPyEndAllowThreads(__tstate);
28314 if (PyErr_Occurred()) SWIG_fail;
28315 }
28316 {
28317 #if wxUSE_UNICODE
28318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28319 #else
28320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28321 #endif
28322 }
28323 return resultobj;
28324 fail:
28325 return NULL;
28326 }
28327
28328
28329 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28330 PyObject *resultobj;
28331 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28332 wxString *arg2 = 0 ;
28333 bool temp2 = false ;
28334 PyObject * obj0 = 0 ;
28335 PyObject * obj1 = 0 ;
28336 char *kwnames[] = {
28337 (char *) "self",(char *) "url", NULL
28338 };
28339
28340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28342 if (SWIG_arg_fail(1)) SWIG_fail;
28343 {
28344 arg2 = wxString_in_helper(obj1);
28345 if (arg2 == NULL) SWIG_fail;
28346 temp2 = true;
28347 }
28348 {
28349 PyThreadState* __tstate = wxPyBeginAllowThreads();
28350 (arg1)->SetURL((wxString const &)*arg2);
28351
28352 wxPyEndAllowThreads(__tstate);
28353 if (PyErr_Occurred()) SWIG_fail;
28354 }
28355 Py_INCREF(Py_None); resultobj = Py_None;
28356 {
28357 if (temp2)
28358 delete arg2;
28359 }
28360 return resultobj;
28361 fail:
28362 {
28363 if (temp2)
28364 delete arg2;
28365 }
28366 return NULL;
28367 }
28368
28369
28370 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28371 PyObject *obj;
28372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28373 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28374 Py_INCREF(obj);
28375 return Py_BuildValue((char *)"");
28376 }
28377 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28378 PyObject *resultobj;
28379 wxMetafileDataObject *result;
28380 char *kwnames[] = {
28381 NULL
28382 };
28383
28384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28385 {
28386 PyThreadState* __tstate = wxPyBeginAllowThreads();
28387 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28388
28389 wxPyEndAllowThreads(__tstate);
28390 if (PyErr_Occurred()) SWIG_fail;
28391 }
28392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28393 return resultobj;
28394 fail:
28395 return NULL;
28396 }
28397
28398
28399 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28400 PyObject *resultobj;
28401 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28402 wxMetafile *arg2 = 0 ;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char *kwnames[] = {
28406 (char *) "self",(char *) "metafile", NULL
28407 };
28408
28409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(1)) SWIG_fail;
28412 {
28413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28414 if (SWIG_arg_fail(2)) SWIG_fail;
28415 if (arg2 == NULL) {
28416 SWIG_null_ref("wxMetafile");
28417 }
28418 if (SWIG_arg_fail(2)) SWIG_fail;
28419 }
28420 {
28421 PyThreadState* __tstate = wxPyBeginAllowThreads();
28422 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28423
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 Py_INCREF(Py_None); resultobj = Py_None;
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28435 PyObject *resultobj;
28436 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28437 wxMetafile result;
28438 PyObject * obj0 = 0 ;
28439 char *kwnames[] = {
28440 (char *) "self", NULL
28441 };
28442
28443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28445 if (SWIG_arg_fail(1)) SWIG_fail;
28446 {
28447 PyThreadState* __tstate = wxPyBeginAllowThreads();
28448 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28449
28450 wxPyEndAllowThreads(__tstate);
28451 if (PyErr_Occurred()) SWIG_fail;
28452 }
28453 {
28454 wxMetafile * resultptr;
28455 resultptr = new wxMetafile((wxMetafile &)(result));
28456 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28457 }
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28465 PyObject *obj;
28466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28467 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28468 Py_INCREF(obj);
28469 return Py_BuildValue((char *)"");
28470 }
28471 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28472 PyObject *resultobj;
28473 wxDragResult arg1 ;
28474 bool result;
28475 PyObject * obj0 = 0 ;
28476 char *kwnames[] = {
28477 (char *) "res", NULL
28478 };
28479
28480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28481 {
28482 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28483 if (SWIG_arg_fail(1)) SWIG_fail;
28484 }
28485 {
28486 PyThreadState* __tstate = wxPyBeginAllowThreads();
28487 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28488
28489 wxPyEndAllowThreads(__tstate);
28490 if (PyErr_Occurred()) SWIG_fail;
28491 }
28492 {
28493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28494 }
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28502 PyObject *resultobj;
28503 wxWindow *arg1 = (wxWindow *) 0 ;
28504 wxCursor const &arg2_defvalue = wxNullCursor ;
28505 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28506 wxCursor const &arg3_defvalue = wxNullCursor ;
28507 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28508 wxCursor const &arg4_defvalue = wxNullCursor ;
28509 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28510 wxPyDropSource *result;
28511 PyObject * obj0 = 0 ;
28512 PyObject * obj1 = 0 ;
28513 PyObject * obj2 = 0 ;
28514 PyObject * obj3 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 if (obj1) {
28523 {
28524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 if (arg2 == NULL) {
28527 SWIG_null_ref("wxCursor");
28528 }
28529 if (SWIG_arg_fail(2)) SWIG_fail;
28530 }
28531 }
28532 if (obj2) {
28533 {
28534 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28535 if (SWIG_arg_fail(3)) SWIG_fail;
28536 if (arg3 == NULL) {
28537 SWIG_null_ref("wxCursor");
28538 }
28539 if (SWIG_arg_fail(3)) SWIG_fail;
28540 }
28541 }
28542 if (obj3) {
28543 {
28544 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28545 if (SWIG_arg_fail(4)) SWIG_fail;
28546 if (arg4 == NULL) {
28547 SWIG_null_ref("wxCursor");
28548 }
28549 if (SWIG_arg_fail(4)) SWIG_fail;
28550 }
28551 }
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj;
28568 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28569 PyObject *arg2 = (PyObject *) 0 ;
28570 PyObject *arg3 = (PyObject *) 0 ;
28571 int arg4 ;
28572 PyObject * obj0 = 0 ;
28573 PyObject * obj1 = 0 ;
28574 PyObject * obj2 = 0 ;
28575 PyObject * obj3 = 0 ;
28576 char *kwnames[] = {
28577 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28578 };
28579
28580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28582 if (SWIG_arg_fail(1)) SWIG_fail;
28583 arg2 = obj1;
28584 arg3 = obj2;
28585 {
28586 arg4 = (int)(SWIG_As_int(obj3));
28587 if (SWIG_arg_fail(4)) SWIG_fail;
28588 }
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28592
28593 wxPyEndAllowThreads(__tstate);
28594 if (PyErr_Occurred()) SWIG_fail;
28595 }
28596 Py_INCREF(Py_None); resultobj = Py_None;
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28604 PyObject *resultobj;
28605 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28606 PyObject * obj0 = 0 ;
28607 char *kwnames[] = {
28608 (char *) "self", NULL
28609 };
28610
28611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28613 if (SWIG_arg_fail(1)) SWIG_fail;
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 delete arg1;
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 Py_INCREF(Py_None); resultobj = Py_None;
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28629 PyObject *resultobj;
28630 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28631 wxDataObject *arg2 = 0 ;
28632 PyObject * obj0 = 0 ;
28633 PyObject * obj1 = 0 ;
28634 char *kwnames[] = {
28635 (char *) "self",(char *) "data", NULL
28636 };
28637
28638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28640 if (SWIG_arg_fail(1)) SWIG_fail;
28641 {
28642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28643 if (SWIG_arg_fail(2)) SWIG_fail;
28644 if (arg2 == NULL) {
28645 SWIG_null_ref("wxDataObject");
28646 }
28647 if (SWIG_arg_fail(2)) SWIG_fail;
28648 }
28649 {
28650 PyThreadState* __tstate = wxPyBeginAllowThreads();
28651 (arg1)->SetData(*arg2);
28652
28653 wxPyEndAllowThreads(__tstate);
28654 if (PyErr_Occurred()) SWIG_fail;
28655 }
28656 Py_INCREF(Py_None); resultobj = Py_None;
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28664 PyObject *resultobj;
28665 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28666 wxDataObject *result;
28667 PyObject * obj0 = 0 ;
28668 char *kwnames[] = {
28669 (char *) "self", NULL
28670 };
28671
28672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) goto fail;
28673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28674 if (SWIG_arg_fail(1)) SWIG_fail;
28675 {
28676 PyThreadState* __tstate = wxPyBeginAllowThreads();
28677 result = (wxDataObject *)(arg1)->GetDataObject();
28678
28679 wxPyEndAllowThreads(__tstate);
28680 if (PyErr_Occurred()) SWIG_fail;
28681 }
28682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28683 return resultobj;
28684 fail:
28685 return NULL;
28686 }
28687
28688
28689 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28690 PyObject *resultobj;
28691 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28692 wxDragResult arg2 ;
28693 wxCursor *arg3 = 0 ;
28694 PyObject * obj0 = 0 ;
28695 PyObject * obj1 = 0 ;
28696 PyObject * obj2 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self",(char *) "res",(char *) "cursor", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28703 if (SWIG_arg_fail(1)) SWIG_fail;
28704 {
28705 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28706 if (SWIG_arg_fail(2)) SWIG_fail;
28707 }
28708 {
28709 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28710 if (SWIG_arg_fail(3)) SWIG_fail;
28711 if (arg3 == NULL) {
28712 SWIG_null_ref("wxCursor");
28713 }
28714 if (SWIG_arg_fail(3)) SWIG_fail;
28715 }
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28719
28720 wxPyEndAllowThreads(__tstate);
28721 if (PyErr_Occurred()) SWIG_fail;
28722 }
28723 Py_INCREF(Py_None); resultobj = Py_None;
28724 return resultobj;
28725 fail:
28726 return NULL;
28727 }
28728
28729
28730 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28731 PyObject *resultobj;
28732 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28733 int arg2 = (int) wxDrag_CopyOnly ;
28734 wxDragResult result;
28735 PyObject * obj0 = 0 ;
28736 PyObject * obj1 = 0 ;
28737 char *kwnames[] = {
28738 (char *) "self",(char *) "flags", NULL
28739 };
28740
28741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28743 if (SWIG_arg_fail(1)) SWIG_fail;
28744 if (obj1) {
28745 {
28746 arg2 = (int)(SWIG_As_int(obj1));
28747 if (SWIG_arg_fail(2)) SWIG_fail;
28748 }
28749 }
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28753
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_From_int((result));
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28765 PyObject *resultobj;
28766 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28767 wxDragResult arg2 ;
28768 bool result;
28769 PyObject * obj0 = 0 ;
28770 PyObject * obj1 = 0 ;
28771 char *kwnames[] = {
28772 (char *) "self",(char *) "effect", NULL
28773 };
28774
28775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28777 if (SWIG_arg_fail(1)) SWIG_fail;
28778 {
28779 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28780 if (SWIG_arg_fail(2)) SWIG_fail;
28781 }
28782 {
28783 PyThreadState* __tstate = wxPyBeginAllowThreads();
28784 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28785
28786 wxPyEndAllowThreads(__tstate);
28787 if (PyErr_Occurred()) SWIG_fail;
28788 }
28789 {
28790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28791 }
28792 return resultobj;
28793 fail:
28794 return NULL;
28795 }
28796
28797
28798 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28799 PyObject *obj;
28800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28801 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28802 Py_INCREF(obj);
28803 return Py_BuildValue((char *)"");
28804 }
28805 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28806 PyObject *resultobj;
28807 wxDataObject *arg1 = (wxDataObject *) NULL ;
28808 wxPyDropTarget *result;
28809 PyObject * obj0 = 0 ;
28810 char *kwnames[] = {
28811 (char *) "dataObject", NULL
28812 };
28813
28814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28815 if (obj0) {
28816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28817 if (SWIG_arg_fail(1)) SWIG_fail;
28818 }
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28822
28823 wxPyEndAllowThreads(__tstate);
28824 if (PyErr_Occurred()) SWIG_fail;
28825 }
28826 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28827 return resultobj;
28828 fail:
28829 return NULL;
28830 }
28831
28832
28833 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28834 PyObject *resultobj;
28835 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28836 PyObject *arg2 = (PyObject *) 0 ;
28837 PyObject *arg3 = (PyObject *) 0 ;
28838 PyObject * obj0 = 0 ;
28839 PyObject * obj1 = 0 ;
28840 PyObject * obj2 = 0 ;
28841 char *kwnames[] = {
28842 (char *) "self",(char *) "self",(char *) "_class", NULL
28843 };
28844
28845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28847 if (SWIG_arg_fail(1)) SWIG_fail;
28848 arg2 = obj1;
28849 arg3 = obj2;
28850 {
28851 PyThreadState* __tstate = wxPyBeginAllowThreads();
28852 (arg1)->_setCallbackInfo(arg2,arg3);
28853
28854 wxPyEndAllowThreads(__tstate);
28855 if (PyErr_Occurred()) SWIG_fail;
28856 }
28857 Py_INCREF(Py_None); resultobj = Py_None;
28858 return resultobj;
28859 fail:
28860 return NULL;
28861 }
28862
28863
28864 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28865 PyObject *resultobj;
28866 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28867 PyObject * obj0 = 0 ;
28868 char *kwnames[] = {
28869 (char *) "self", NULL
28870 };
28871
28872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28874 if (SWIG_arg_fail(1)) SWIG_fail;
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 delete arg1;
28878
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 Py_INCREF(Py_None); resultobj = Py_None;
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj;
28891 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28892 wxDataObject *result;
28893 PyObject * obj0 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (wxDataObject *)(arg1)->GetDataObject();
28904
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28916 PyObject *resultobj;
28917 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28918 wxDataObject *arg2 = (wxDataObject *) 0 ;
28919 PyObject * obj0 = 0 ;
28920 PyObject * obj1 = 0 ;
28921 char *kwnames[] = {
28922 (char *) "self",(char *) "dataObject", NULL
28923 };
28924
28925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28927 if (SWIG_arg_fail(1)) SWIG_fail;
28928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28929 if (SWIG_arg_fail(2)) SWIG_fail;
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 (arg1)->SetDataObject(arg2);
28933
28934 wxPyEndAllowThreads(__tstate);
28935 if (PyErr_Occurred()) SWIG_fail;
28936 }
28937 Py_INCREF(Py_None); resultobj = Py_None;
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28945 PyObject *resultobj;
28946 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28947 int arg2 ;
28948 int arg3 ;
28949 wxDragResult arg4 ;
28950 wxDragResult result;
28951 PyObject * obj0 = 0 ;
28952 PyObject * obj1 = 0 ;
28953 PyObject * obj2 = 0 ;
28954 PyObject * obj3 = 0 ;
28955 char *kwnames[] = {
28956 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28957 };
28958
28959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28961 if (SWIG_arg_fail(1)) SWIG_fail;
28962 {
28963 arg2 = (int)(SWIG_As_int(obj1));
28964 if (SWIG_arg_fail(2)) SWIG_fail;
28965 }
28966 {
28967 arg3 = (int)(SWIG_As_int(obj2));
28968 if (SWIG_arg_fail(3)) SWIG_fail;
28969 }
28970 {
28971 arg4 = (wxDragResult)(SWIG_As_int(obj3));
28972 if (SWIG_arg_fail(4)) SWIG_fail;
28973 }
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
28977
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 resultobj = SWIG_From_int((result));
28982 return resultobj;
28983 fail:
28984 return NULL;
28985 }
28986
28987
28988 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
28989 PyObject *resultobj;
28990 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28991 int arg2 ;
28992 int arg3 ;
28993 wxDragResult arg4 ;
28994 wxDragResult result;
28995 PyObject * obj0 = 0 ;
28996 PyObject * obj1 = 0 ;
28997 PyObject * obj2 = 0 ;
28998 PyObject * obj3 = 0 ;
28999 char *kwnames[] = {
29000 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29001 };
29002
29003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29005 if (SWIG_arg_fail(1)) SWIG_fail;
29006 {
29007 arg2 = (int)(SWIG_As_int(obj1));
29008 if (SWIG_arg_fail(2)) SWIG_fail;
29009 }
29010 {
29011 arg3 = (int)(SWIG_As_int(obj2));
29012 if (SWIG_arg_fail(3)) SWIG_fail;
29013 }
29014 {
29015 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29016 if (SWIG_arg_fail(4)) SWIG_fail;
29017 }
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 resultobj = SWIG_From_int((result));
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29035 PyObject * obj0 = 0 ;
29036 char *kwnames[] = {
29037 (char *) "self", NULL
29038 };
29039
29040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29042 if (SWIG_arg_fail(1)) SWIG_fail;
29043 {
29044 PyThreadState* __tstate = wxPyBeginAllowThreads();
29045 (arg1)->base_OnLeave();
29046
29047 wxPyEndAllowThreads(__tstate);
29048 if (PyErr_Occurred()) SWIG_fail;
29049 }
29050 Py_INCREF(Py_None); resultobj = Py_None;
29051 return resultobj;
29052 fail:
29053 return NULL;
29054 }
29055
29056
29057 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29058 PyObject *resultobj;
29059 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29060 int arg2 ;
29061 int arg3 ;
29062 bool result;
29063 PyObject * obj0 = 0 ;
29064 PyObject * obj1 = 0 ;
29065 PyObject * obj2 = 0 ;
29066 char *kwnames[] = {
29067 (char *) "self",(char *) "x",(char *) "y", NULL
29068 };
29069
29070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29072 if (SWIG_arg_fail(1)) SWIG_fail;
29073 {
29074 arg2 = (int)(SWIG_As_int(obj1));
29075 if (SWIG_arg_fail(2)) SWIG_fail;
29076 }
29077 {
29078 arg3 = (int)(SWIG_As_int(obj2));
29079 if (SWIG_arg_fail(3)) SWIG_fail;
29080 }
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29084
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 {
29089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29090 }
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj;
29099 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29100 bool result;
29101 PyObject * obj0 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 result = (bool)(arg1)->GetData();
29112
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 {
29117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29118 }
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29126 PyObject *obj;
29127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29128 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29129 Py_INCREF(obj);
29130 return Py_BuildValue((char *)"");
29131 }
29132 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj;
29134 wxPyTextDropTarget *result;
29135 char *kwnames[] = {
29136 NULL
29137 };
29138
29139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29143
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj;
29156 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29157 PyObject *arg2 = (PyObject *) 0 ;
29158 PyObject *arg3 = (PyObject *) 0 ;
29159 PyObject * obj0 = 0 ;
29160 PyObject * obj1 = 0 ;
29161 PyObject * obj2 = 0 ;
29162 char *kwnames[] = {
29163 (char *) "self",(char *) "self",(char *) "_class", NULL
29164 };
29165
29166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29168 if (SWIG_arg_fail(1)) SWIG_fail;
29169 arg2 = obj1;
29170 arg3 = obj2;
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 (arg1)->_setCallbackInfo(arg2,arg3);
29174
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 Py_INCREF(Py_None); resultobj = Py_None;
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29186 PyObject *resultobj;
29187 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29188 int arg2 ;
29189 int arg3 ;
29190 wxDragResult arg4 ;
29191 wxDragResult result;
29192 PyObject * obj0 = 0 ;
29193 PyObject * obj1 = 0 ;
29194 PyObject * obj2 = 0 ;
29195 PyObject * obj3 = 0 ;
29196 char *kwnames[] = {
29197 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29198 };
29199
29200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29202 if (SWIG_arg_fail(1)) SWIG_fail;
29203 {
29204 arg2 = (int)(SWIG_As_int(obj1));
29205 if (SWIG_arg_fail(2)) SWIG_fail;
29206 }
29207 {
29208 arg3 = (int)(SWIG_As_int(obj2));
29209 if (SWIG_arg_fail(3)) SWIG_fail;
29210 }
29211 {
29212 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29213 if (SWIG_arg_fail(4)) SWIG_fail;
29214 }
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 resultobj = SWIG_From_int((result));
29223 return resultobj;
29224 fail:
29225 return NULL;
29226 }
29227
29228
29229 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29230 PyObject *resultobj;
29231 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29232 int arg2 ;
29233 int arg3 ;
29234 wxDragResult arg4 ;
29235 wxDragResult result;
29236 PyObject * obj0 = 0 ;
29237 PyObject * obj1 = 0 ;
29238 PyObject * obj2 = 0 ;
29239 PyObject * obj3 = 0 ;
29240 char *kwnames[] = {
29241 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29242 };
29243
29244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29246 if (SWIG_arg_fail(1)) SWIG_fail;
29247 {
29248 arg2 = (int)(SWIG_As_int(obj1));
29249 if (SWIG_arg_fail(2)) SWIG_fail;
29250 }
29251 {
29252 arg3 = (int)(SWIG_As_int(obj2));
29253 if (SWIG_arg_fail(3)) SWIG_fail;
29254 }
29255 {
29256 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29257 if (SWIG_arg_fail(4)) SWIG_fail;
29258 }
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29262
29263 wxPyEndAllowThreads(__tstate);
29264 if (PyErr_Occurred()) SWIG_fail;
29265 }
29266 resultobj = SWIG_From_int((result));
29267 return resultobj;
29268 fail:
29269 return NULL;
29270 }
29271
29272
29273 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29274 PyObject *resultobj;
29275 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29276 PyObject * obj0 = 0 ;
29277 char *kwnames[] = {
29278 (char *) "self", NULL
29279 };
29280
29281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29283 if (SWIG_arg_fail(1)) SWIG_fail;
29284 {
29285 PyThreadState* __tstate = wxPyBeginAllowThreads();
29286 (arg1)->base_OnLeave();
29287
29288 wxPyEndAllowThreads(__tstate);
29289 if (PyErr_Occurred()) SWIG_fail;
29290 }
29291 Py_INCREF(Py_None); resultobj = Py_None;
29292 return resultobj;
29293 fail:
29294 return NULL;
29295 }
29296
29297
29298 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj;
29300 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29301 int arg2 ;
29302 int arg3 ;
29303 bool result;
29304 PyObject * obj0 = 0 ;
29305 PyObject * obj1 = 0 ;
29306 PyObject * obj2 = 0 ;
29307 char *kwnames[] = {
29308 (char *) "self",(char *) "x",(char *) "y", NULL
29309 };
29310
29311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29313 if (SWIG_arg_fail(1)) SWIG_fail;
29314 {
29315 arg2 = (int)(SWIG_As_int(obj1));
29316 if (SWIG_arg_fail(2)) SWIG_fail;
29317 }
29318 {
29319 arg3 = (int)(SWIG_As_int(obj2));
29320 if (SWIG_arg_fail(3)) SWIG_fail;
29321 }
29322 {
29323 PyThreadState* __tstate = wxPyBeginAllowThreads();
29324 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29325
29326 wxPyEndAllowThreads(__tstate);
29327 if (PyErr_Occurred()) SWIG_fail;
29328 }
29329 {
29330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29331 }
29332 return resultobj;
29333 fail:
29334 return NULL;
29335 }
29336
29337
29338 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29339 PyObject *resultobj;
29340 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29341 int arg2 ;
29342 int arg3 ;
29343 wxDragResult arg4 ;
29344 wxDragResult result;
29345 PyObject * obj0 = 0 ;
29346 PyObject * obj1 = 0 ;
29347 PyObject * obj2 = 0 ;
29348 PyObject * obj3 = 0 ;
29349 char *kwnames[] = {
29350 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29351 };
29352
29353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(1)) SWIG_fail;
29356 {
29357 arg2 = (int)(SWIG_As_int(obj1));
29358 if (SWIG_arg_fail(2)) SWIG_fail;
29359 }
29360 {
29361 arg3 = (int)(SWIG_As_int(obj2));
29362 if (SWIG_arg_fail(3)) SWIG_fail;
29363 }
29364 {
29365 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29366 if (SWIG_arg_fail(4)) SWIG_fail;
29367 }
29368 {
29369 PyThreadState* __tstate = wxPyBeginAllowThreads();
29370 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29371
29372 wxPyEndAllowThreads(__tstate);
29373 if (PyErr_Occurred()) SWIG_fail;
29374 }
29375 resultobj = SWIG_From_int((result));
29376 return resultobj;
29377 fail:
29378 return NULL;
29379 }
29380
29381
29382 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29383 PyObject *obj;
29384 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29385 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29386 Py_INCREF(obj);
29387 return Py_BuildValue((char *)"");
29388 }
29389 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29390 PyObject *resultobj;
29391 wxPyFileDropTarget *result;
29392 char *kwnames[] = {
29393 NULL
29394 };
29395
29396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29412 PyObject *resultobj;
29413 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29414 PyObject *arg2 = (PyObject *) 0 ;
29415 PyObject *arg3 = (PyObject *) 0 ;
29416 PyObject * obj0 = 0 ;
29417 PyObject * obj1 = 0 ;
29418 PyObject * obj2 = 0 ;
29419 char *kwnames[] = {
29420 (char *) "self",(char *) "self",(char *) "_class", NULL
29421 };
29422
29423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29425 if (SWIG_arg_fail(1)) SWIG_fail;
29426 arg2 = obj1;
29427 arg3 = obj2;
29428 {
29429 PyThreadState* __tstate = wxPyBeginAllowThreads();
29430 (arg1)->_setCallbackInfo(arg2,arg3);
29431
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 Py_INCREF(Py_None); resultobj = Py_None;
29436 return resultobj;
29437 fail:
29438 return NULL;
29439 }
29440
29441
29442 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29443 PyObject *resultobj;
29444 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29445 int arg2 ;
29446 int arg3 ;
29447 wxDragResult arg4 ;
29448 wxDragResult result;
29449 PyObject * obj0 = 0 ;
29450 PyObject * obj1 = 0 ;
29451 PyObject * obj2 = 0 ;
29452 PyObject * obj3 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 {
29461 arg2 = (int)(SWIG_As_int(obj1));
29462 if (SWIG_arg_fail(2)) SWIG_fail;
29463 }
29464 {
29465 arg3 = (int)(SWIG_As_int(obj2));
29466 if (SWIG_arg_fail(3)) SWIG_fail;
29467 }
29468 {
29469 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29470 if (SWIG_arg_fail(4)) SWIG_fail;
29471 }
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29475
29476 wxPyEndAllowThreads(__tstate);
29477 if (PyErr_Occurred()) SWIG_fail;
29478 }
29479 resultobj = SWIG_From_int((result));
29480 return resultobj;
29481 fail:
29482 return NULL;
29483 }
29484
29485
29486 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29487 PyObject *resultobj;
29488 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29489 int arg2 ;
29490 int arg3 ;
29491 wxDragResult arg4 ;
29492 wxDragResult result;
29493 PyObject * obj0 = 0 ;
29494 PyObject * obj1 = 0 ;
29495 PyObject * obj2 = 0 ;
29496 PyObject * obj3 = 0 ;
29497 char *kwnames[] = {
29498 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29499 };
29500
29501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29503 if (SWIG_arg_fail(1)) SWIG_fail;
29504 {
29505 arg2 = (int)(SWIG_As_int(obj1));
29506 if (SWIG_arg_fail(2)) SWIG_fail;
29507 }
29508 {
29509 arg3 = (int)(SWIG_As_int(obj2));
29510 if (SWIG_arg_fail(3)) SWIG_fail;
29511 }
29512 {
29513 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29514 if (SWIG_arg_fail(4)) SWIG_fail;
29515 }
29516 {
29517 PyThreadState* __tstate = wxPyBeginAllowThreads();
29518 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29519
29520 wxPyEndAllowThreads(__tstate);
29521 if (PyErr_Occurred()) SWIG_fail;
29522 }
29523 resultobj = SWIG_From_int((result));
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29531 PyObject *resultobj;
29532 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29533 PyObject * obj0 = 0 ;
29534 char *kwnames[] = {
29535 (char *) "self", NULL
29536 };
29537
29538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29540 if (SWIG_arg_fail(1)) SWIG_fail;
29541 {
29542 PyThreadState* __tstate = wxPyBeginAllowThreads();
29543 (arg1)->base_OnLeave();
29544
29545 wxPyEndAllowThreads(__tstate);
29546 if (PyErr_Occurred()) SWIG_fail;
29547 }
29548 Py_INCREF(Py_None); resultobj = Py_None;
29549 return resultobj;
29550 fail:
29551 return NULL;
29552 }
29553
29554
29555 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29556 PyObject *resultobj;
29557 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29558 int arg2 ;
29559 int arg3 ;
29560 bool result;
29561 PyObject * obj0 = 0 ;
29562 PyObject * obj1 = 0 ;
29563 PyObject * obj2 = 0 ;
29564 char *kwnames[] = {
29565 (char *) "self",(char *) "x",(char *) "y", NULL
29566 };
29567
29568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29570 if (SWIG_arg_fail(1)) SWIG_fail;
29571 {
29572 arg2 = (int)(SWIG_As_int(obj1));
29573 if (SWIG_arg_fail(2)) SWIG_fail;
29574 }
29575 {
29576 arg3 = (int)(SWIG_As_int(obj2));
29577 if (SWIG_arg_fail(3)) SWIG_fail;
29578 }
29579 {
29580 PyThreadState* __tstate = wxPyBeginAllowThreads();
29581 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29582
29583 wxPyEndAllowThreads(__tstate);
29584 if (PyErr_Occurred()) SWIG_fail;
29585 }
29586 {
29587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29588 }
29589 return resultobj;
29590 fail:
29591 return NULL;
29592 }
29593
29594
29595 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29596 PyObject *resultobj;
29597 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29598 int arg2 ;
29599 int arg3 ;
29600 wxDragResult arg4 ;
29601 wxDragResult result;
29602 PyObject * obj0 = 0 ;
29603 PyObject * obj1 = 0 ;
29604 PyObject * obj2 = 0 ;
29605 PyObject * obj3 = 0 ;
29606 char *kwnames[] = {
29607 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29608 };
29609
29610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29612 if (SWIG_arg_fail(1)) SWIG_fail;
29613 {
29614 arg2 = (int)(SWIG_As_int(obj1));
29615 if (SWIG_arg_fail(2)) SWIG_fail;
29616 }
29617 {
29618 arg3 = (int)(SWIG_As_int(obj2));
29619 if (SWIG_arg_fail(3)) SWIG_fail;
29620 }
29621 {
29622 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29623 if (SWIG_arg_fail(4)) SWIG_fail;
29624 }
29625 {
29626 PyThreadState* __tstate = wxPyBeginAllowThreads();
29627 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29628
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 resultobj = SWIG_From_int((result));
29633 return resultobj;
29634 fail:
29635 return NULL;
29636 }
29637
29638
29639 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29640 PyObject *obj;
29641 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29642 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29643 Py_INCREF(obj);
29644 return Py_BuildValue((char *)"");
29645 }
29646 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29647 PyObject *resultobj;
29648 wxClipboard *result;
29649 char *kwnames[] = {
29650 NULL
29651 };
29652
29653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = (wxClipboard *)new wxClipboard();
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29669 PyObject *resultobj;
29670 wxClipboard *arg1 = (wxClipboard *) 0 ;
29671 PyObject * obj0 = 0 ;
29672 char *kwnames[] = {
29673 (char *) "self", NULL
29674 };
29675
29676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29678 if (SWIG_arg_fail(1)) SWIG_fail;
29679 {
29680 PyThreadState* __tstate = wxPyBeginAllowThreads();
29681 delete arg1;
29682
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 Py_INCREF(Py_None); resultobj = Py_None;
29687 return resultobj;
29688 fail:
29689 return NULL;
29690 }
29691
29692
29693 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29694 PyObject *resultobj;
29695 wxClipboard *arg1 = (wxClipboard *) 0 ;
29696 bool result;
29697 PyObject * obj0 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 result = (bool)(arg1)->Open();
29708
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 {
29713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29714 }
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29722 PyObject *resultobj;
29723 wxClipboard *arg1 = (wxClipboard *) 0 ;
29724 PyObject * obj0 = 0 ;
29725 char *kwnames[] = {
29726 (char *) "self", NULL
29727 };
29728
29729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29731 if (SWIG_arg_fail(1)) SWIG_fail;
29732 {
29733 PyThreadState* __tstate = wxPyBeginAllowThreads();
29734 (arg1)->Close();
29735
29736 wxPyEndAllowThreads(__tstate);
29737 if (PyErr_Occurred()) SWIG_fail;
29738 }
29739 Py_INCREF(Py_None); resultobj = Py_None;
29740 return resultobj;
29741 fail:
29742 return NULL;
29743 }
29744
29745
29746 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29747 PyObject *resultobj;
29748 wxClipboard *arg1 = (wxClipboard *) 0 ;
29749 bool result;
29750 PyObject * obj0 = 0 ;
29751 char *kwnames[] = {
29752 (char *) "self", NULL
29753 };
29754
29755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29757 if (SWIG_arg_fail(1)) SWIG_fail;
29758 {
29759 PyThreadState* __tstate = wxPyBeginAllowThreads();
29760 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29761
29762 wxPyEndAllowThreads(__tstate);
29763 if (PyErr_Occurred()) SWIG_fail;
29764 }
29765 {
29766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29767 }
29768 return resultobj;
29769 fail:
29770 return NULL;
29771 }
29772
29773
29774 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29775 PyObject *resultobj;
29776 wxClipboard *arg1 = (wxClipboard *) 0 ;
29777 wxDataObject *arg2 = (wxDataObject *) 0 ;
29778 bool result;
29779 PyObject * obj0 = 0 ;
29780 PyObject * obj1 = 0 ;
29781 char *kwnames[] = {
29782 (char *) "self",(char *) "data", NULL
29783 };
29784
29785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29787 if (SWIG_arg_fail(1)) SWIG_fail;
29788 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29789 if (SWIG_arg_fail(2)) SWIG_fail;
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 result = (bool)(arg1)->AddData(arg2);
29793
29794 wxPyEndAllowThreads(__tstate);
29795 if (PyErr_Occurred()) SWIG_fail;
29796 }
29797 {
29798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29799 }
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29807 PyObject *resultobj;
29808 wxClipboard *arg1 = (wxClipboard *) 0 ;
29809 wxDataObject *arg2 = (wxDataObject *) 0 ;
29810 bool result;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 char *kwnames[] = {
29814 (char *) "self",(char *) "data", NULL
29815 };
29816
29817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29819 if (SWIG_arg_fail(1)) SWIG_fail;
29820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29821 if (SWIG_arg_fail(2)) SWIG_fail;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (bool)(arg1)->SetData(arg2);
29825
29826 wxPyEndAllowThreads(__tstate);
29827 if (PyErr_Occurred()) SWIG_fail;
29828 }
29829 {
29830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxClipboard *arg1 = (wxClipboard *) 0 ;
29841 wxDataFormat *arg2 = 0 ;
29842 bool result;
29843 PyObject * obj0 = 0 ;
29844 PyObject * obj1 = 0 ;
29845 char *kwnames[] = {
29846 (char *) "self",(char *) "format", NULL
29847 };
29848
29849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29851 if (SWIG_arg_fail(1)) SWIG_fail;
29852 {
29853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29854 if (SWIG_arg_fail(2)) SWIG_fail;
29855 if (arg2 == NULL) {
29856 SWIG_null_ref("wxDataFormat");
29857 }
29858 if (SWIG_arg_fail(2)) SWIG_fail;
29859 }
29860 {
29861 PyThreadState* __tstate = wxPyBeginAllowThreads();
29862 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29863
29864 wxPyEndAllowThreads(__tstate);
29865 if (PyErr_Occurred()) SWIG_fail;
29866 }
29867 {
29868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29869 }
29870 return resultobj;
29871 fail:
29872 return NULL;
29873 }
29874
29875
29876 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29877 PyObject *resultobj;
29878 wxClipboard *arg1 = (wxClipboard *) 0 ;
29879 wxDataObject *arg2 = 0 ;
29880 bool result;
29881 PyObject * obj0 = 0 ;
29882 PyObject * obj1 = 0 ;
29883 char *kwnames[] = {
29884 (char *) "self",(char *) "data", NULL
29885 };
29886
29887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29889 if (SWIG_arg_fail(1)) SWIG_fail;
29890 {
29891 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29892 if (SWIG_arg_fail(2)) SWIG_fail;
29893 if (arg2 == NULL) {
29894 SWIG_null_ref("wxDataObject");
29895 }
29896 if (SWIG_arg_fail(2)) SWIG_fail;
29897 }
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (bool)(arg1)->GetData(*arg2);
29901
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 {
29906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29907 }
29908 return resultobj;
29909 fail:
29910 return NULL;
29911 }
29912
29913
29914 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29915 PyObject *resultobj;
29916 wxClipboard *arg1 = (wxClipboard *) 0 ;
29917 PyObject * obj0 = 0 ;
29918 char *kwnames[] = {
29919 (char *) "self", NULL
29920 };
29921
29922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29924 if (SWIG_arg_fail(1)) SWIG_fail;
29925 {
29926 PyThreadState* __tstate = wxPyBeginAllowThreads();
29927 (arg1)->Clear();
29928
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 Py_INCREF(Py_None); resultobj = Py_None;
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj;
29941 wxClipboard *arg1 = (wxClipboard *) 0 ;
29942 bool result;
29943 PyObject * obj0 = 0 ;
29944 char *kwnames[] = {
29945 (char *) "self", NULL
29946 };
29947
29948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) goto fail;
29949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29950 if (SWIG_arg_fail(1)) SWIG_fail;
29951 {
29952 PyThreadState* __tstate = wxPyBeginAllowThreads();
29953 result = (bool)(arg1)->Flush();
29954
29955 wxPyEndAllowThreads(__tstate);
29956 if (PyErr_Occurred()) SWIG_fail;
29957 }
29958 {
29959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29960 }
29961 return resultobj;
29962 fail:
29963 return NULL;
29964 }
29965
29966
29967 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29968 PyObject *resultobj;
29969 wxClipboard *arg1 = (wxClipboard *) 0 ;
29970 bool arg2 = (bool) true ;
29971 PyObject * obj0 = 0 ;
29972 PyObject * obj1 = 0 ;
29973 char *kwnames[] = {
29974 (char *) "self",(char *) "primary", NULL
29975 };
29976
29977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
29978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29979 if (SWIG_arg_fail(1)) SWIG_fail;
29980 if (obj1) {
29981 {
29982 arg2 = (bool)(SWIG_As_bool(obj1));
29983 if (SWIG_arg_fail(2)) SWIG_fail;
29984 }
29985 }
29986 {
29987 PyThreadState* __tstate = wxPyBeginAllowThreads();
29988 (arg1)->UsePrimarySelection(arg2);
29989
29990 wxPyEndAllowThreads(__tstate);
29991 if (PyErr_Occurred()) SWIG_fail;
29992 }
29993 Py_INCREF(Py_None); resultobj = Py_None;
29994 return resultobj;
29995 fail:
29996 return NULL;
29997 }
29998
29999
30000 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30001 PyObject *resultobj;
30002 wxClipboard *result;
30003 char *kwnames[] = {
30004 NULL
30005 };
30006
30007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30008 {
30009 PyThreadState* __tstate = wxPyBeginAllowThreads();
30010 result = (wxClipboard *)wxClipboard::Get();
30011
30012 wxPyEndAllowThreads(__tstate);
30013 if (PyErr_Occurred()) SWIG_fail;
30014 }
30015 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30016 return resultobj;
30017 fail:
30018 return NULL;
30019 }
30020
30021
30022 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30023 PyObject *obj;
30024 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30025 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30026 Py_INCREF(obj);
30027 return Py_BuildValue((char *)"");
30028 }
30029 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj;
30031 wxClipboard *arg1 = (wxClipboard *) NULL ;
30032 wxClipboardLocker *result;
30033 PyObject * obj0 = 0 ;
30034 char *kwnames[] = {
30035 (char *) "clipboard", NULL
30036 };
30037
30038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30039 if (obj0) {
30040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30041 if (SWIG_arg_fail(1)) SWIG_fail;
30042 }
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30046
30047 wxPyEndAllowThreads(__tstate);
30048 if (PyErr_Occurred()) SWIG_fail;
30049 }
30050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30051 return resultobj;
30052 fail:
30053 return NULL;
30054 }
30055
30056
30057 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30058 PyObject *resultobj;
30059 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30060 PyObject * obj0 = 0 ;
30061 char *kwnames[] = {
30062 (char *) "self", NULL
30063 };
30064
30065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30067 if (SWIG_arg_fail(1)) SWIG_fail;
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 delete arg1;
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 Py_INCREF(Py_None); resultobj = Py_None;
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj;
30084 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30085 bool result;
30086 PyObject * obj0 = 0 ;
30087 char *kwnames[] = {
30088 (char *) "self", NULL
30089 };
30090
30091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30093 if (SWIG_arg_fail(1)) SWIG_fail;
30094 {
30095 PyThreadState* __tstate = wxPyBeginAllowThreads();
30096 result = (bool)wxClipboardLocker___nonzero__(arg1);
30097
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 {
30102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30103 }
30104 return resultobj;
30105 fail:
30106 return NULL;
30107 }
30108
30109
30110 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30111 PyObject *obj;
30112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30113 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30114 Py_INCREF(obj);
30115 return Py_BuildValue((char *)"");
30116 }
30117 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj;
30119 int arg1 = (int) 0 ;
30120 int arg2 = (int) 0 ;
30121 int arg3 = (int) 0 ;
30122 int arg4 = (int) 0 ;
30123 wxVideoMode *result;
30124 PyObject * obj0 = 0 ;
30125 PyObject * obj1 = 0 ;
30126 PyObject * obj2 = 0 ;
30127 PyObject * obj3 = 0 ;
30128 char *kwnames[] = {
30129 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30130 };
30131
30132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30133 if (obj0) {
30134 {
30135 arg1 = (int)(SWIG_As_int(obj0));
30136 if (SWIG_arg_fail(1)) SWIG_fail;
30137 }
30138 }
30139 if (obj1) {
30140 {
30141 arg2 = (int)(SWIG_As_int(obj1));
30142 if (SWIG_arg_fail(2)) SWIG_fail;
30143 }
30144 }
30145 if (obj2) {
30146 {
30147 arg3 = (int)(SWIG_As_int(obj2));
30148 if (SWIG_arg_fail(3)) SWIG_fail;
30149 }
30150 }
30151 if (obj3) {
30152 {
30153 arg4 = (int)(SWIG_As_int(obj3));
30154 if (SWIG_arg_fail(4)) SWIG_fail;
30155 }
30156 }
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30160
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30165 return resultobj;
30166 fail:
30167 return NULL;
30168 }
30169
30170
30171 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30172 PyObject *resultobj;
30173 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30174 PyObject * obj0 = 0 ;
30175 char *kwnames[] = {
30176 (char *) "self", NULL
30177 };
30178
30179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30181 if (SWIG_arg_fail(1)) SWIG_fail;
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 delete arg1;
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 Py_INCREF(Py_None); resultobj = Py_None;
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj;
30198 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30199 wxVideoMode *arg2 = 0 ;
30200 bool result;
30201 PyObject * obj0 = 0 ;
30202 PyObject * obj1 = 0 ;
30203 char *kwnames[] = {
30204 (char *) "self",(char *) "other", NULL
30205 };
30206
30207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30209 if (SWIG_arg_fail(1)) SWIG_fail;
30210 {
30211 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(2)) SWIG_fail;
30213 if (arg2 == NULL) {
30214 SWIG_null_ref("wxVideoMode");
30215 }
30216 if (SWIG_arg_fail(2)) SWIG_fail;
30217 }
30218 {
30219 PyThreadState* __tstate = wxPyBeginAllowThreads();
30220 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30221
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 {
30226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30227 }
30228 return resultobj;
30229 fail:
30230 return NULL;
30231 }
30232
30233
30234 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30235 PyObject *resultobj;
30236 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30237 int result;
30238 PyObject * obj0 = 0 ;
30239 char *kwnames[] = {
30240 (char *) "self", NULL
30241 };
30242
30243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30245 if (SWIG_arg_fail(1)) SWIG_fail;
30246 {
30247 PyThreadState* __tstate = wxPyBeginAllowThreads();
30248 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30249
30250 wxPyEndAllowThreads(__tstate);
30251 if (PyErr_Occurred()) SWIG_fail;
30252 }
30253 {
30254 resultobj = SWIG_From_int((int)(result));
30255 }
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30263 PyObject *resultobj;
30264 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30265 int result;
30266 PyObject * obj0 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "self", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30273 if (SWIG_arg_fail(1)) SWIG_fail;
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 {
30282 resultobj = SWIG_From_int((int)(result));
30283 }
30284 return resultobj;
30285 fail:
30286 return NULL;
30287 }
30288
30289
30290 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30291 PyObject *resultobj;
30292 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30293 int result;
30294 PyObject * obj0 = 0 ;
30295 char *kwnames[] = {
30296 (char *) "self", NULL
30297 };
30298
30299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30301 if (SWIG_arg_fail(1)) SWIG_fail;
30302 {
30303 PyThreadState* __tstate = wxPyBeginAllowThreads();
30304 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30305
30306 wxPyEndAllowThreads(__tstate);
30307 if (PyErr_Occurred()) SWIG_fail;
30308 }
30309 {
30310 resultobj = SWIG_From_int((int)(result));
30311 }
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj;
30320 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30321 bool result;
30322 PyObject * obj0 = 0 ;
30323 char *kwnames[] = {
30324 (char *) "self", NULL
30325 };
30326
30327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30329 if (SWIG_arg_fail(1)) SWIG_fail;
30330 {
30331 PyThreadState* __tstate = wxPyBeginAllowThreads();
30332 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30333
30334 wxPyEndAllowThreads(__tstate);
30335 if (PyErr_Occurred()) SWIG_fail;
30336 }
30337 {
30338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30339 }
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30347 PyObject *resultobj;
30348 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30349 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30350 bool result;
30351 PyObject * obj0 = 0 ;
30352 PyObject * obj1 = 0 ;
30353 char *kwnames[] = {
30354 (char *) "self",(char *) "other", NULL
30355 };
30356
30357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30359 if (SWIG_arg_fail(1)) SWIG_fail;
30360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30361 if (SWIG_arg_fail(2)) SWIG_fail;
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30365
30366 wxPyEndAllowThreads(__tstate);
30367 if (PyErr_Occurred()) SWIG_fail;
30368 }
30369 {
30370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30371 }
30372 return resultobj;
30373 fail:
30374 return NULL;
30375 }
30376
30377
30378 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30379 PyObject *resultobj;
30380 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30381 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30382 bool result;
30383 PyObject * obj0 = 0 ;
30384 PyObject * obj1 = 0 ;
30385 char *kwnames[] = {
30386 (char *) "self",(char *) "other", NULL
30387 };
30388
30389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30391 if (SWIG_arg_fail(1)) SWIG_fail;
30392 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30393 if (SWIG_arg_fail(2)) SWIG_fail;
30394 {
30395 PyThreadState* __tstate = wxPyBeginAllowThreads();
30396 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30397
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 {
30402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30403 }
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj;
30412 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30413 int arg2 ;
30414 PyObject * obj0 = 0 ;
30415 PyObject * obj1 = 0 ;
30416 char *kwnames[] = {
30417 (char *) "self",(char *) "w", NULL
30418 };
30419
30420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(1)) SWIG_fail;
30423 {
30424 arg2 = (int)(SWIG_As_int(obj1));
30425 if (SWIG_arg_fail(2)) SWIG_fail;
30426 }
30427 if (arg1) (arg1)->w = arg2;
30428
30429 Py_INCREF(Py_None); resultobj = Py_None;
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj;
30438 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30439 int result;
30440 PyObject * obj0 = 0 ;
30441 char *kwnames[] = {
30442 (char *) "self", NULL
30443 };
30444
30445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30447 if (SWIG_arg_fail(1)) SWIG_fail;
30448 result = (int) ((arg1)->w);
30449
30450 {
30451 resultobj = SWIG_From_int((int)(result));
30452 }
30453 return resultobj;
30454 fail:
30455 return NULL;
30456 }
30457
30458
30459 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30460 PyObject *resultobj;
30461 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30462 int arg2 ;
30463 PyObject * obj0 = 0 ;
30464 PyObject * obj1 = 0 ;
30465 char *kwnames[] = {
30466 (char *) "self",(char *) "h", NULL
30467 };
30468
30469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30471 if (SWIG_arg_fail(1)) SWIG_fail;
30472 {
30473 arg2 = (int)(SWIG_As_int(obj1));
30474 if (SWIG_arg_fail(2)) SWIG_fail;
30475 }
30476 if (arg1) (arg1)->h = arg2;
30477
30478 Py_INCREF(Py_None); resultobj = Py_None;
30479 return resultobj;
30480 fail:
30481 return NULL;
30482 }
30483
30484
30485 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30486 PyObject *resultobj;
30487 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30488 int result;
30489 PyObject * obj0 = 0 ;
30490 char *kwnames[] = {
30491 (char *) "self", NULL
30492 };
30493
30494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30496 if (SWIG_arg_fail(1)) SWIG_fail;
30497 result = (int) ((arg1)->h);
30498
30499 {
30500 resultobj = SWIG_From_int((int)(result));
30501 }
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30509 PyObject *resultobj;
30510 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30511 int arg2 ;
30512 PyObject * obj0 = 0 ;
30513 PyObject * obj1 = 0 ;
30514 char *kwnames[] = {
30515 (char *) "self",(char *) "bpp", NULL
30516 };
30517
30518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30520 if (SWIG_arg_fail(1)) SWIG_fail;
30521 {
30522 arg2 = (int)(SWIG_As_int(obj1));
30523 if (SWIG_arg_fail(2)) SWIG_fail;
30524 }
30525 if (arg1) (arg1)->bpp = arg2;
30526
30527 Py_INCREF(Py_None); resultobj = Py_None;
30528 return resultobj;
30529 fail:
30530 return NULL;
30531 }
30532
30533
30534 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30535 PyObject *resultobj;
30536 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30537 int result;
30538 PyObject * obj0 = 0 ;
30539 char *kwnames[] = {
30540 (char *) "self", NULL
30541 };
30542
30543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30545 if (SWIG_arg_fail(1)) SWIG_fail;
30546 result = (int) ((arg1)->bpp);
30547
30548 {
30549 resultobj = SWIG_From_int((int)(result));
30550 }
30551 return resultobj;
30552 fail:
30553 return NULL;
30554 }
30555
30556
30557 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30558 PyObject *resultobj;
30559 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30560 int arg2 ;
30561 PyObject * obj0 = 0 ;
30562 PyObject * obj1 = 0 ;
30563 char *kwnames[] = {
30564 (char *) "self",(char *) "refresh", NULL
30565 };
30566
30567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30569 if (SWIG_arg_fail(1)) SWIG_fail;
30570 {
30571 arg2 = (int)(SWIG_As_int(obj1));
30572 if (SWIG_arg_fail(2)) SWIG_fail;
30573 }
30574 if (arg1) (arg1)->refresh = arg2;
30575
30576 Py_INCREF(Py_None); resultobj = Py_None;
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30584 PyObject *resultobj;
30585 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30586 int result;
30587 PyObject * obj0 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 result = (int) ((arg1)->refresh);
30596
30597 {
30598 resultobj = SWIG_From_int((int)(result));
30599 }
30600 return resultobj;
30601 fail:
30602 return NULL;
30603 }
30604
30605
30606 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30607 PyObject *obj;
30608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30609 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30610 Py_INCREF(obj);
30611 return Py_BuildValue((char *)"");
30612 }
30613 static int _wrap_DefaultVideoMode_set(PyObject *) {
30614 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30615 return 1;
30616 }
30617
30618
30619 static PyObject *_wrap_DefaultVideoMode_get(void) {
30620 PyObject *pyobj;
30621
30622 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30623 return pyobj;
30624 }
30625
30626
30627 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj;
30629 size_t arg1 = (size_t) 0 ;
30630 wxDisplay *result;
30631 PyObject * obj0 = 0 ;
30632 char *kwnames[] = {
30633 (char *) "index", NULL
30634 };
30635
30636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30637 if (obj0) {
30638 {
30639 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30640 if (SWIG_arg_fail(1)) SWIG_fail;
30641 }
30642 }
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 result = (wxDisplay *)new wxDisplay(arg1);
30646
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30658 PyObject *resultobj;
30659 wxDisplay *arg1 = (wxDisplay *) 0 ;
30660 PyObject * obj0 = 0 ;
30661 char *kwnames[] = {
30662 (char *) "self", NULL
30663 };
30664
30665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30667 if (SWIG_arg_fail(1)) SWIG_fail;
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 delete arg1;
30671
30672 wxPyEndAllowThreads(__tstate);
30673 if (PyErr_Occurred()) SWIG_fail;
30674 }
30675 Py_INCREF(Py_None); resultobj = Py_None;
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj;
30684 size_t result;
30685 char *kwnames[] = {
30686 NULL
30687 };
30688
30689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30690 {
30691 PyThreadState* __tstate = wxPyBeginAllowThreads();
30692 result = (size_t)wxDisplay::GetCount();
30693
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 {
30698 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30699 }
30700 return resultobj;
30701 fail:
30702 return NULL;
30703 }
30704
30705
30706 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30707 PyObject *resultobj;
30708 wxPoint *arg1 = 0 ;
30709 int result;
30710 wxPoint temp1 ;
30711 PyObject * obj0 = 0 ;
30712 char *kwnames[] = {
30713 (char *) "pt", NULL
30714 };
30715
30716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30717 {
30718 arg1 = &temp1;
30719 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30720 }
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30724
30725 wxPyEndAllowThreads(__tstate);
30726 if (PyErr_Occurred()) SWIG_fail;
30727 }
30728 {
30729 resultobj = SWIG_From_int((int)(result));
30730 }
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj;
30739 wxWindow *arg1 = (wxWindow *) 0 ;
30740 int result;
30741 PyObject * obj0 = 0 ;
30742 char *kwnames[] = {
30743 (char *) "window", NULL
30744 };
30745
30746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30748 if (SWIG_arg_fail(1)) SWIG_fail;
30749 {
30750 PyThreadState* __tstate = wxPyBeginAllowThreads();
30751 result = (int)Display_GetFromWindow(arg1);
30752
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 {
30757 resultobj = SWIG_From_int((int)(result));
30758 }
30759 return resultobj;
30760 fail:
30761 return NULL;
30762 }
30763
30764
30765 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30766 PyObject *resultobj;
30767 wxDisplay *arg1 = (wxDisplay *) 0 ;
30768 bool result;
30769 PyObject * obj0 = 0 ;
30770 char *kwnames[] = {
30771 (char *) "self", NULL
30772 };
30773
30774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30776 if (SWIG_arg_fail(1)) SWIG_fail;
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 result = (bool)((wxDisplay const *)arg1)->IsOk();
30780
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 {
30785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30786 }
30787 return resultobj;
30788 fail:
30789 return NULL;
30790 }
30791
30792
30793 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30794 PyObject *resultobj;
30795 wxDisplay *arg1 = (wxDisplay *) 0 ;
30796 wxRect result;
30797 PyObject * obj0 = 0 ;
30798 char *kwnames[] = {
30799 (char *) "self", NULL
30800 };
30801
30802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30804 if (SWIG_arg_fail(1)) SWIG_fail;
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 result = ((wxDisplay const *)arg1)->GetGeometry();
30808
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 {
30813 wxRect * resultptr;
30814 resultptr = new wxRect((wxRect &)(result));
30815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30816 }
30817 return resultobj;
30818 fail:
30819 return NULL;
30820 }
30821
30822
30823 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30824 PyObject *resultobj;
30825 wxDisplay *arg1 = (wxDisplay *) 0 ;
30826 wxString result;
30827 PyObject * obj0 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = ((wxDisplay const *)arg1)->GetName();
30838
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 {
30843 #if wxUSE_UNICODE
30844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30845 #else
30846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30847 #endif
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj;
30857 wxDisplay *arg1 = (wxDisplay *) 0 ;
30858 bool result;
30859 PyObject * obj0 = 0 ;
30860 char *kwnames[] = {
30861 (char *) "self", NULL
30862 };
30863
30864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30866 if (SWIG_arg_fail(1)) SWIG_fail;
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30870
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 {
30875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30876 }
30877 return resultobj;
30878 fail:
30879 return NULL;
30880 }
30881
30882
30883 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30884 PyObject *resultobj;
30885 wxDisplay *arg1 = (wxDisplay *) 0 ;
30886 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30887 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30888 PyObject *result;
30889 PyObject * obj0 = 0 ;
30890 PyObject * obj1 = 0 ;
30891 char *kwnames[] = {
30892 (char *) "self",(char *) "mode", NULL
30893 };
30894
30895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30897 if (SWIG_arg_fail(1)) SWIG_fail;
30898 if (obj1) {
30899 {
30900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30901 if (SWIG_arg_fail(2)) SWIG_fail;
30902 if (arg2 == NULL) {
30903 SWIG_null_ref("wxVideoMode");
30904 }
30905 if (SWIG_arg_fail(2)) SWIG_fail;
30906 }
30907 }
30908 {
30909 PyThreadState* __tstate = wxPyBeginAllowThreads();
30910 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30911
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = result;
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30923 PyObject *resultobj;
30924 wxDisplay *arg1 = (wxDisplay *) 0 ;
30925 wxVideoMode result;
30926 PyObject * obj0 = 0 ;
30927 char *kwnames[] = {
30928 (char *) "self", NULL
30929 };
30930
30931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30933 if (SWIG_arg_fail(1)) SWIG_fail;
30934 {
30935 PyThreadState* __tstate = wxPyBeginAllowThreads();
30936 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30937
30938 wxPyEndAllowThreads(__tstate);
30939 if (PyErr_Occurred()) SWIG_fail;
30940 }
30941 {
30942 wxVideoMode * resultptr;
30943 resultptr = new wxVideoMode((wxVideoMode &)(result));
30944 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxDisplay *arg1 = (wxDisplay *) 0 ;
30955 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30956 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30957 bool result;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 char *kwnames[] = {
30961 (char *) "self",(char *) "mode", NULL
30962 };
30963
30964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30966 if (SWIG_arg_fail(1)) SWIG_fail;
30967 if (obj1) {
30968 {
30969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30970 if (SWIG_arg_fail(2)) SWIG_fail;
30971 if (arg2 == NULL) {
30972 SWIG_null_ref("wxVideoMode");
30973 }
30974 if (SWIG_arg_fail(2)) SWIG_fail;
30975 }
30976 }
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
30980
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 {
30985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30986 }
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxDisplay *arg1 = (wxDisplay *) 0 ;
30996 PyObject * obj0 = 0 ;
30997 char *kwnames[] = {
30998 (char *) "self", NULL
30999 };
31000
31001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31003 if (SWIG_arg_fail(1)) SWIG_fail;
31004 {
31005 PyThreadState* __tstate = wxPyBeginAllowThreads();
31006 (arg1)->ResetMode();
31007
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 Py_INCREF(Py_None); resultobj = Py_None;
31012 return resultobj;
31013 fail:
31014 return NULL;
31015 }
31016
31017
31018 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31019 PyObject *obj;
31020 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31021 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31022 Py_INCREF(obj);
31023 return Py_BuildValue((char *)"");
31024 }
31025 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31026 PyObject *resultobj;
31027 wxStandardPaths *result;
31028 char *kwnames[] = {
31029 NULL
31030 };
31031
31032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31033 {
31034 PyThreadState* __tstate = wxPyBeginAllowThreads();
31035 result = (wxStandardPaths *)StandardPaths_Get();
31036
31037 wxPyEndAllowThreads(__tstate);
31038 if (PyErr_Occurred()) SWIG_fail;
31039 }
31040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31048 PyObject *resultobj;
31049 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31050 wxString result;
31051 PyObject * obj0 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31062
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 {
31067 #if wxUSE_UNICODE
31068 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31069 #else
31070 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31071 #endif
31072 }
31073 return resultobj;
31074 fail:
31075 return NULL;
31076 }
31077
31078
31079 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31080 PyObject *resultobj;
31081 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31082 wxString result;
31083 PyObject * obj0 = 0 ;
31084 char *kwnames[] = {
31085 (char *) "self", NULL
31086 };
31087
31088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31090 if (SWIG_arg_fail(1)) SWIG_fail;
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31094
31095 wxPyEndAllowThreads(__tstate);
31096 if (PyErr_Occurred()) SWIG_fail;
31097 }
31098 {
31099 #if wxUSE_UNICODE
31100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31101 #else
31102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31103 #endif
31104 }
31105 return resultobj;
31106 fail:
31107 return NULL;
31108 }
31109
31110
31111 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31112 PyObject *resultobj;
31113 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31114 wxString result;
31115 PyObject * obj0 = 0 ;
31116 char *kwnames[] = {
31117 (char *) "self", NULL
31118 };
31119
31120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31122 if (SWIG_arg_fail(1)) SWIG_fail;
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31126
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 {
31131 #if wxUSE_UNICODE
31132 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31133 #else
31134 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31135 #endif
31136 }
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31144 PyObject *resultobj;
31145 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31146 wxString result;
31147 PyObject * obj0 = 0 ;
31148 char *kwnames[] = {
31149 (char *) "self", NULL
31150 };
31151
31152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31154 if (SWIG_arg_fail(1)) SWIG_fail;
31155 {
31156 PyThreadState* __tstate = wxPyBeginAllowThreads();
31157 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31158
31159 wxPyEndAllowThreads(__tstate);
31160 if (PyErr_Occurred()) SWIG_fail;
31161 }
31162 {
31163 #if wxUSE_UNICODE
31164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31165 #else
31166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31167 #endif
31168 }
31169 return resultobj;
31170 fail:
31171 return NULL;
31172 }
31173
31174
31175 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31176 PyObject *resultobj;
31177 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31178 wxString result;
31179 PyObject * obj0 = 0 ;
31180 char *kwnames[] = {
31181 (char *) "self", NULL
31182 };
31183
31184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31186 if (SWIG_arg_fail(1)) SWIG_fail;
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31190
31191 wxPyEndAllowThreads(__tstate);
31192 if (PyErr_Occurred()) SWIG_fail;
31193 }
31194 {
31195 #if wxUSE_UNICODE
31196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31197 #else
31198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31199 #endif
31200 }
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31208 PyObject *resultobj;
31209 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31210 wxString result;
31211 PyObject * obj0 = 0 ;
31212 char *kwnames[] = {
31213 (char *) "self", NULL
31214 };
31215
31216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31218 if (SWIG_arg_fail(1)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31222
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 {
31227 #if wxUSE_UNICODE
31228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31229 #else
31230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31231 #endif
31232 }
31233 return resultobj;
31234 fail:
31235 return NULL;
31236 }
31237
31238
31239 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31240 PyObject *resultobj;
31241 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31242 wxString result;
31243 PyObject * obj0 = 0 ;
31244 char *kwnames[] = {
31245 (char *) "self", NULL
31246 };
31247
31248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31250 if (SWIG_arg_fail(1)) SWIG_fail;
31251 {
31252 PyThreadState* __tstate = wxPyBeginAllowThreads();
31253 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31254
31255 wxPyEndAllowThreads(__tstate);
31256 if (PyErr_Occurred()) SWIG_fail;
31257 }
31258 {
31259 #if wxUSE_UNICODE
31260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31261 #else
31262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31263 #endif
31264 }
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj;
31273 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31274 wxString *arg2 = 0 ;
31275 bool temp2 = false ;
31276 PyObject * obj0 = 0 ;
31277 PyObject * obj1 = 0 ;
31278 char *kwnames[] = {
31279 (char *) "self",(char *) "prefix", NULL
31280 };
31281
31282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31284 if (SWIG_arg_fail(1)) SWIG_fail;
31285 {
31286 arg2 = wxString_in_helper(obj1);
31287 if (arg2 == NULL) SWIG_fail;
31288 temp2 = true;
31289 }
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31293
31294 wxPyEndAllowThreads(__tstate);
31295 if (PyErr_Occurred()) SWIG_fail;
31296 }
31297 Py_INCREF(Py_None); resultobj = Py_None;
31298 {
31299 if (temp2)
31300 delete arg2;
31301 }
31302 return resultobj;
31303 fail:
31304 {
31305 if (temp2)
31306 delete arg2;
31307 }
31308 return NULL;
31309 }
31310
31311
31312 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31313 PyObject *resultobj;
31314 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31315 wxString result;
31316 PyObject * obj0 = 0 ;
31317 char *kwnames[] = {
31318 (char *) "self", NULL
31319 };
31320
31321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31323 if (SWIG_arg_fail(1)) SWIG_fail;
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = wxStandardPaths_GetInstallPrefix(arg1);
31327
31328 wxPyEndAllowThreads(__tstate);
31329 if (PyErr_Occurred()) SWIG_fail;
31330 }
31331 {
31332 #if wxUSE_UNICODE
31333 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31334 #else
31335 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31336 #endif
31337 }
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31345 PyObject *obj;
31346 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31347 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31348 Py_INCREF(obj);
31349 return Py_BuildValue((char *)"");
31350 }
31351 static PyMethodDef SwigMethods[] = {
31352 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31353 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31354 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31355 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31356 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31357 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31358 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31359 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31360 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31361 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31362 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31363 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31364 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31365 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31366 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31367 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31368 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31369 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31370 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31371 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31372 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31373 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31374 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31375 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31376 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31377 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31378 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31379 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31380 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31381 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31388 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31395 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31430 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31438 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31456 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31459 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31462 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31465 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31467 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31471 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31485 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31488 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31491 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31494 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31497 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31500 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31514 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31517 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31518 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31520 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31521 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31526 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31529 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31543 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31546 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31547 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31548 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31550 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31552 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31554 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31561 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31567 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31577 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31579 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31581 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31583 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31585 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31588 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31590 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31596 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31605 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31610 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31613 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31614 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31617 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31634 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31642 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31660 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31678 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31688 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31689 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31704 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31707 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31717 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31720 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31733 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31734 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31743 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31749 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31763 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31773 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31786 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31789 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31792 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31796 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31816 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31819 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31822 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31826 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31889 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31890 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31891 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31892 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31909 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31919 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31920 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31921 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31922 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31939 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31954 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31984 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
31988 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
31996 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
31997 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32002 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32011 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32018 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32021 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32024 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32026 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32027 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32029 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32032 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32036 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32039 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32041 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32043 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32044 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32051 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32052 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32054 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32056 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32059 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32062 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32066 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32069 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32073 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32074 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32077 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32078 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32082 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32085 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32086 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32093 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32096 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32107 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32111 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32115 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32123 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32129 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32137 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32141 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32143 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32154 { NULL, NULL, 0, NULL }
32155 };
32156
32157
32158 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32159
32160 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32161 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32162 }
32163 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32164 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32165 }
32166 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32167 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32168 }
32169 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32170 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32171 }
32172 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32173 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32174 }
32175 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32176 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32177 }
32178 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32179 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32180 }
32181 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32182 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32183 }
32184 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32185 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32186 }
32187 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32188 return (void *)((wxEvent *) ((wxPyEvent *) x));
32189 }
32190 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32192 }
32193 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32194 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32195 }
32196 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32197 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32198 }
32199 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32200 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32201 }
32202 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32203 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32204 }
32205 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32206 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32207 }
32208 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32209 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32210 }
32211 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32212 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32213 }
32214 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32215 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32216 }
32217 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32218 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32219 }
32220 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32221 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32222 }
32223 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32224 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32225 }
32226 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32227 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32228 }
32229 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32230 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32231 }
32232 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32233 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32234 }
32235 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32236 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32237 }
32238 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32239 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32240 }
32241 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32242 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32243 }
32244 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32245 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32246 }
32247 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32248 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32249 }
32250 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32252 }
32253 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32254 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32255 }
32256 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32257 return (void *)((wxEvent *) ((wxShowEvent *) x));
32258 }
32259 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32260 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32261 }
32262 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32263 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32264 }
32265 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32266 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32267 }
32268 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32269 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32270 }
32271 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32272 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32273 }
32274 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32275 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32276 }
32277 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32278 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32279 }
32280 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32281 return (void *)((wxConfigBase *) ((wxConfig *) x));
32282 }
32283 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32284 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32285 }
32286 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32287 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32288 }
32289 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32290 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32291 }
32292 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32293 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32294 }
32295 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32296 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32297 }
32298 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32299 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32300 }
32301 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32302 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32303 }
32304 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32305 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32306 }
32307 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32308 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32309 }
32310 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32311 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32312 }
32313 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32314 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32315 }
32316 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32317 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32318 }
32319 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32320 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32321 }
32322 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32323 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32324 }
32325 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32326 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32327 }
32328 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32329 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32330 }
32331 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32332 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32333 }
32334 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32335 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32336 }
32337 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32338 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32339 }
32340 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32341 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32342 }
32343 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32344 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32345 }
32346 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32347 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32348 }
32349 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32350 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32351 }
32352 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32353 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32354 }
32355 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32356 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32357 }
32358 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32359 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32360 }
32361 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32362 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32363 }
32364 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32365 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32366 }
32367 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32368 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32369 }
32370 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32371 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32372 }
32373 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32374 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32375 }
32376 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32377 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32378 }
32379 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32380 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32381 }
32382 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32383 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32384 }
32385 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32386 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32387 }
32388 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32389 return (void *)((wxObject *) ((wxSizerItem *) x));
32390 }
32391 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32392 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32393 }
32394 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32395 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32396 }
32397 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32398 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32399 }
32400 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32401 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32402 }
32403 static void *_p_wxSizerTo_p_wxObject(void *x) {
32404 return (void *)((wxObject *) ((wxSizer *) x));
32405 }
32406 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32407 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32408 }
32409 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32410 return (void *)((wxObject *) ((wxFileHistory *) x));
32411 }
32412 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32413 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32414 }
32415 static void *_p_wxEventTo_p_wxObject(void *x) {
32416 return (void *)((wxObject *) ((wxEvent *) x));
32417 }
32418 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32419 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32420 }
32421 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32422 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32423 }
32424 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32425 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32426 }
32427 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32428 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32429 }
32430 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32431 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32432 }
32433 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32434 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32435 }
32436 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32437 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32438 }
32439 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32440 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32441 }
32442 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32443 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32444 }
32445 static void *_p_wxControlTo_p_wxObject(void *x) {
32446 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32447 }
32448 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32449 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32450 }
32451 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32452 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32453 }
32454 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32455 return (void *)((wxObject *) ((wxFSFile *) x));
32456 }
32457 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32458 return (void *)((wxObject *) ((wxClipboard *) x));
32459 }
32460 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32461 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32462 }
32463 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32464 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32465 }
32466 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32467 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32468 }
32469 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32470 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32471 }
32472 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32473 return (void *)((wxObject *) ((wxToolTip *) x));
32474 }
32475 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32476 return (void *)((wxObject *) ((wxMenuItem *) x));
32477 }
32478 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32480 }
32481 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32483 }
32484 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32486 }
32487 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32489 }
32490 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32492 }
32493 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32495 }
32496 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32498 }
32499 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32501 }
32502 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32504 }
32505 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32507 }
32508 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32510 }
32511 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32513 }
32514 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32516 }
32517 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32519 }
32520 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32522 }
32523 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32525 }
32526 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32528 }
32529 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32531 }
32532 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32534 }
32535 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) ((wxImageHandler *) x));
32537 }
32538 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32540 }
32541 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) ((wxEvtHandler *) x));
32543 }
32544 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32546 }
32547 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32549 }
32550 static void *_p_wxImageTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) ((wxImage *) x));
32552 }
32553 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32555 }
32556 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) ((wxSystemOptions *) x));
32558 }
32559 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32561 }
32562 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32564 }
32565 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32567 }
32568 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32570 }
32571 static void *_p_wxWindowTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32573 }
32574 static void *_p_wxMenuTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32576 }
32577 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32579 }
32580 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32582 }
32583 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) ((wxFileSystem *) x));
32585 }
32586 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32588 }
32589 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32591 }
32592 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32594 }
32595 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32597 }
32598 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32600 }
32601 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32603 }
32604 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) ((wxBusyInfo *) x));
32606 }
32607 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32609 }
32610 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32612 }
32613 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32615 }
32616 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32618 }
32619 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32621 }
32622 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32624 }
32625 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32627 }
32628 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32630 }
32631 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32633 }
32634 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32636 }
32637 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32638 return (void *)((wxLog *) ((wxLogStderr *) x));
32639 }
32640 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32641 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32642 }
32643 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32644 return (void *)((wxLog *) ((wxLogWindow *) x));
32645 }
32646 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32647 return (void *)((wxLog *) ((wxLogChain *) x));
32648 }
32649 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32650 return (void *)((wxLog *) ((wxLogGui *) x));
32651 }
32652 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32653 return (void *)((wxLog *) ((wxPyLog *) x));
32654 }
32655 static void *_p_wxControlTo_p_wxWindow(void *x) {
32656 return (void *)((wxWindow *) ((wxControl *) x));
32657 }
32658 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32659 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32660 }
32661 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32662 return (void *)((wxWindow *) ((wxMenuBar *) x));
32663 }
32664 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32665 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32666 }
32667 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32668 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32669 }
32670 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}};
32671 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}};
32672 static swig_type_info _swigt__p_wxMetafile[] = {{"_p_wxMetafile", 0, "wxMetafile *", 0, 0, 0, 0},{"_p_wxMetafile", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
32673 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}};
32674 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}};
32675 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}};
32676 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}};
32677 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}};
32678 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}};
32679 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}};
32680 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}};
32681 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}};
32682 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}};
32683 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}};
32684 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}};
32685 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}};
32686 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}};
32687 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}};
32688 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}};
32689 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}};
32690 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}};
32691 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}};
32692 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}};
32693 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}};
32694 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}};
32695 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}};
32696 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}};
32697 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}};
32698 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}};
32699 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}};
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747 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}};
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767
32768 static swig_type_info *swig_types_initial[] = {
32769 _swigt__p_wxLogChain,
32770 _swigt__p_wxMutexGuiLocker,
32771 _swigt__p_wxMetafile,
32772 _swigt__p_wxFileHistory,
32773 _swigt__p_wxLog,
32774 _swigt__p_wxMenu,
32775 _swigt__p_wxEvent,
32776 _swigt__p_wxDateTime__TimeZone,
32777 _swigt__p_wxConfigBase,
32778 _swigt__p_wxDisplay,
32779 _swigt__p_wxFileType,
32780 _swigt__p_wxLogGui,
32781 _swigt__p_wxFont,
32782 _swigt__p_wxDataFormat,
32783 _swigt__p_wxTimerEvent,
32784 _swigt__p_wxCaret,
32785 _swigt__ptrdiff_t,
32786 _swigt__std__ptrdiff_t,
32787 _swigt__p_int,
32788 _swigt__p_wxSize,
32789 _swigt__p_wxClipboard,
32790 _swigt__p_wxStopWatch,
32791 _swigt__p_wxDC,
32792 _swigt__p_wxClipboardLocker,
32793 _swigt__p_wxIcon,
32794 _swigt__p_wxLogStderr,
32795 _swigt__p_wxLogTextCtrl,
32796 _swigt__p_wxTextCtrl,
32797 _swigt__p_wxBusyCursor,
32798 _swigt__p_wxBitmapDataObject,
32799 _swigt__p_wxTextDataObject,
32800 _swigt__p_wxDataObject,
32801 _swigt__p_wxPyTextDataObject,
32802 _swigt__p_wxPyBitmapDataObject,
32803 _swigt__p_wxFileDataObject,
32804 _swigt__p_wxCustomDataObject,
32805 _swigt__p_wxURLDataObject,
32806 _swigt__p_wxMetafileDataObject,
32807 _swigt__p_wxSound,
32808 _swigt__p_wxTimerRunner,
32809 _swigt__p_wxLogWindow,
32810 _swigt__p_wxTimeSpan,
32811 _swigt__p_wxArrayString,
32812 _swigt__p_wxWindowDisabler,
32813 _swigt__p_form_ops_t,
32814 _swigt__p_wxToolTip,
32815 _swigt__p_wxDataObjectComposite,
32816 _swigt__p_wxSystemSettings,
32817 _swigt__p_wxFileConfig,
32818 _swigt__p_wxVideoMode,
32819 _swigt__p_wxDataObjectSimple,
32820 _swigt__p_wxPyDataObjectSimple,
32821 _swigt__p_wxDuplexMode,
32822 _swigt__p_wxEvtHandler,
32823 _swigt__p_wxRect,
32824 _swigt__p_char,
32825 _swigt__p_wxSingleInstanceChecker,
32826 _swigt__p_wxStandardPaths,
32827 _swigt__p_wxFileTypeInfo,
32828 _swigt__p_wxFrame,
32829 _swigt__p_wxTimer,
32830 _swigt__p_wxPaperSize,
32831 _swigt__p_wxMimeTypesManager,
32832 _swigt__p_wxPyArtProvider,
32833 _swigt__p_wxPyTipProvider,
32834 _swigt__p_wxTipProvider,
32835 _swigt__p_wxJoystick,
32836 _swigt__p_wxSystemOptions,
32837 _swigt__p_wxPoint,
32838 _swigt__p_wxJoystickEvent,
32839 _swigt__p_wxCursor,
32840 _swigt__p_wxObject,
32841 _swigt__p_wxOutputStream,
32842 _swigt__p_wxDateTime,
32843 _swigt__p_wxPyDropSource,
32844 _swigt__p_unsigned_long,
32845 _swigt__p_wxKillError,
32846 _swigt__p_wxWindow,
32847 _swigt__p_wxString,
32848 _swigt__p_wxPyProcess,
32849 _swigt__p_wxBitmap,
32850 _swigt__p_wxConfig,
32851 _swigt__unsigned_int,
32852 _swigt__p_unsigned_int,
32853 _swigt__p_unsigned_char,
32854 _swigt__p_wxChar,
32855 _swigt__p_wxBusyInfo,
32856 _swigt__p_wxPyDropTarget,
32857 _swigt__p_wxPyTextDropTarget,
32858 _swigt__p_wxPyFileDropTarget,
32859 _swigt__p_wxProcessEvent,
32860 _swigt__p_wxPyLog,
32861 _swigt__p_wxLogNull,
32862 _swigt__p_wxColour,
32863 _swigt__p_wxPyTimer,
32864 _swigt__p_wxConfigPathChanger,
32865 _swigt__p_wxDateSpan,
32866 0
32867 };
32868
32869
32870 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32871
32872 static swig_const_info swig_const_table[] = {
32873 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32874 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32875 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32876 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32877 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32878 {0, 0, 0, 0.0, 0, 0}};
32879
32880 #ifdef __cplusplus
32881 }
32882 #endif
32883
32884
32885 #ifdef __cplusplus
32886 extern "C" {
32887 #endif
32888
32889 /* Python-specific SWIG API */
32890 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32891 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32892 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32893
32894 /* -----------------------------------------------------------------------------
32895 * global variable support code.
32896 * ----------------------------------------------------------------------------- */
32897
32898 typedef struct swig_globalvar {
32899 char *name; /* Name of global variable */
32900 PyObject *(*get_attr)(); /* Return the current value */
32901 int (*set_attr)(PyObject *); /* Set the value */
32902 struct swig_globalvar *next;
32903 } swig_globalvar;
32904
32905 typedef struct swig_varlinkobject {
32906 PyObject_HEAD
32907 swig_globalvar *vars;
32908 } swig_varlinkobject;
32909
32910 static PyObject *
32911 swig_varlink_repr(swig_varlinkobject *v) {
32912 v = v;
32913 return PyString_FromString("<Swig global variables>");
32914 }
32915
32916 static int
32917 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32918 swig_globalvar *var;
32919 flags = flags;
32920 fprintf(fp,"Swig global variables { ");
32921 for (var = v->vars; var; var=var->next) {
32922 fprintf(fp,"%s", var->name);
32923 if (var->next) fprintf(fp,", ");
32924 }
32925 fprintf(fp," }\n");
32926 return 0;
32927 }
32928
32929 static PyObject *
32930 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32931 swig_globalvar *var = v->vars;
32932 while (var) {
32933 if (strcmp(var->name,n) == 0) {
32934 return (*var->get_attr)();
32935 }
32936 var = var->next;
32937 }
32938 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32939 return NULL;
32940 }
32941
32942 static int
32943 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32944 swig_globalvar *var = v->vars;
32945 while (var) {
32946 if (strcmp(var->name,n) == 0) {
32947 return (*var->set_attr)(p);
32948 }
32949 var = var->next;
32950 }
32951 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32952 return 1;
32953 }
32954
32955 static PyTypeObject varlinktype = {
32956 PyObject_HEAD_INIT(0)
32957 0, /* Number of items in variable part (ob_size) */
32958 (char *)"swigvarlink", /* Type name (tp_name) */
32959 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32960 0, /* Itemsize (tp_itemsize) */
32961 0, /* Deallocator (tp_dealloc) */
32962 (printfunc) swig_varlink_print, /* Print (tp_print) */
32963 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32964 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32965 0, /* tp_compare */
32966 (reprfunc) swig_varlink_repr, /* tp_repr */
32967 0, /* tp_as_number */
32968 0, /* tp_as_sequence */
32969 0, /* tp_as_mapping */
32970 0, /* tp_hash */
32971 0, /* tp_call */
32972 0, /* tp_str */
32973 0, /* tp_getattro */
32974 0, /* tp_setattro */
32975 0, /* tp_as_buffer */
32976 0, /* tp_flags */
32977 0, /* tp_doc */
32978 #if PY_VERSION_HEX >= 0x02000000
32979 0, /* tp_traverse */
32980 0, /* tp_clear */
32981 #endif
32982 #if PY_VERSION_HEX >= 0x02010000
32983 0, /* tp_richcompare */
32984 0, /* tp_weaklistoffset */
32985 #endif
32986 #if PY_VERSION_HEX >= 0x02020000
32987 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
32988 #endif
32989 #if PY_VERSION_HEX >= 0x02030000
32990 0, /* tp_del */
32991 #endif
32992 #ifdef COUNT_ALLOCS
32993 0,0,0,0 /* tp_alloc -> tp_next */
32994 #endif
32995 };
32996
32997 /* Create a variable linking object for use later */
32998 static PyObject *
32999 SWIG_Python_newvarlink(void) {
33000 swig_varlinkobject *result = 0;
33001 result = PyMem_NEW(swig_varlinkobject,1);
33002 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33003 result->ob_type = &varlinktype;
33004 result->vars = 0;
33005 result->ob_refcnt = 0;
33006 Py_XINCREF((PyObject *) result);
33007 return ((PyObject*) result);
33008 }
33009
33010 static void
33011 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33012 swig_varlinkobject *v;
33013 swig_globalvar *gv;
33014 v= (swig_varlinkobject *) p;
33015 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33016 gv->name = (char *) malloc(strlen(name)+1);
33017 strcpy(gv->name,name);
33018 gv->get_attr = get_attr;
33019 gv->set_attr = set_attr;
33020 gv->next = v->vars;
33021 v->vars = gv;
33022 }
33023
33024 /* -----------------------------------------------------------------------------
33025 * constants/methods manipulation
33026 * ----------------------------------------------------------------------------- */
33027
33028 /* Install Constants */
33029 static void
33030 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33031 PyObject *obj = 0;
33032 size_t i;
33033 for (i = 0; constants[i].type; i++) {
33034 switch(constants[i].type) {
33035 case SWIG_PY_INT:
33036 obj = PyInt_FromLong(constants[i].lvalue);
33037 break;
33038 case SWIG_PY_FLOAT:
33039 obj = PyFloat_FromDouble(constants[i].dvalue);
33040 break;
33041 case SWIG_PY_STRING:
33042 if (constants[i].pvalue) {
33043 obj = PyString_FromString((char *) constants[i].pvalue);
33044 } else {
33045 Py_INCREF(Py_None);
33046 obj = Py_None;
33047 }
33048 break;
33049 case SWIG_PY_POINTER:
33050 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33051 break;
33052 case SWIG_PY_BINARY:
33053 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33054 break;
33055 default:
33056 obj = 0;
33057 break;
33058 }
33059 if (obj) {
33060 PyDict_SetItemString(d,constants[i].name,obj);
33061 Py_DECREF(obj);
33062 }
33063 }
33064 }
33065
33066 /* -----------------------------------------------------------------------------*/
33067 /* Fix SwigMethods to carry the callback ptrs when needed */
33068 /* -----------------------------------------------------------------------------*/
33069
33070 static void
33071 SWIG_Python_FixMethods(PyMethodDef *methods,
33072 swig_const_info *const_table,
33073 swig_type_info **types,
33074 swig_type_info **types_initial) {
33075 size_t i;
33076 for (i = 0; methods[i].ml_name; ++i) {
33077 char *c = methods[i].ml_doc;
33078 if (c && (c = strstr(c, "swig_ptr: "))) {
33079 int j;
33080 swig_const_info *ci = 0;
33081 char *name = c + 10;
33082 for (j = 0; const_table[j].type; j++) {
33083 if (strncmp(const_table[j].name, name,
33084 strlen(const_table[j].name)) == 0) {
33085 ci = &(const_table[j]);
33086 break;
33087 }
33088 }
33089 if (ci) {
33090 size_t shift = (ci->ptype) - types;
33091 swig_type_info *ty = types_initial[shift];
33092 size_t ldoc = (c - methods[i].ml_doc);
33093 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33094 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33095 char *buff = ndoc;
33096 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33097 strncpy(buff, methods[i].ml_doc, ldoc);
33098 buff += ldoc;
33099 strncpy(buff, "swig_ptr: ", 10);
33100 buff += 10;
33101 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33102 methods[i].ml_doc = ndoc;
33103 }
33104 }
33105 }
33106 }
33107
33108 /* -----------------------------------------------------------------------------*
33109 * Initialize type list
33110 * -----------------------------------------------------------------------------*/
33111
33112 #if PY_MAJOR_VERSION < 2
33113 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33114 is copied out of Python/modsupport.c in python version 2.3.4 */
33115 static int
33116 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33117 {
33118 PyObject *dict;
33119 if (!PyModule_Check(m)) {
33120 PyErr_SetString(PyExc_TypeError,
33121 "PyModule_AddObject() needs module as first arg");
33122 return -1;
33123 }
33124 if (!o) {
33125 PyErr_SetString(PyExc_TypeError,
33126 "PyModule_AddObject() needs non-NULL value");
33127 return -1;
33128 }
33129
33130 dict = PyModule_GetDict(m);
33131 if (dict == NULL) {
33132 /* Internal error -- modules must have a dict! */
33133 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33134 PyModule_GetName(m));
33135 return -1;
33136 }
33137 if (PyDict_SetItemString(dict, name, o))
33138 return -1;
33139 Py_DECREF(o);
33140 return 0;
33141 }
33142 #endif
33143
33144 static swig_type_info **
33145 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33146 static PyMethodDef swig_empty_runtime_method_table[] = {
33147 {
33148 NULL, NULL, 0, NULL
33149 }
33150 };/* Sentinel */
33151
33152 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33153 swig_empty_runtime_method_table);
33154 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33155 if (pointer && module) {
33156 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33157 }
33158 return type_list_handle;
33159 }
33160
33161 static swig_type_info **
33162 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33163 swig_type_info **type_pointer;
33164
33165 /* first check if module already created */
33166 type_pointer = SWIG_Python_GetTypeListHandle();
33167 if (type_pointer) {
33168 return type_pointer;
33169 } else {
33170 /* create a new module and variable */
33171 return SWIG_Python_SetTypeListHandle(type_list_handle);
33172 }
33173 }
33174
33175 #ifdef __cplusplus
33176 }
33177 #endif
33178
33179 /* -----------------------------------------------------------------------------*
33180 * Partial Init method
33181 * -----------------------------------------------------------------------------*/
33182
33183 #ifdef SWIG_LINK_RUNTIME
33184 #ifdef __cplusplus
33185 extern "C"
33186 #endif
33187 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33188 #endif
33189
33190 #ifdef __cplusplus
33191 extern "C"
33192 #endif
33193 SWIGEXPORT(void) SWIG_init(void) {
33194 static PyObject *SWIG_globals = 0;
33195 static int typeinit = 0;
33196 PyObject *m, *d;
33197 int i;
33198 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33199
33200 /* Fix SwigMethods to carry the callback ptrs when needed */
33201 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33202
33203 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33204 d = PyModule_GetDict(m);
33205
33206 if (!typeinit) {
33207 #ifdef SWIG_LINK_RUNTIME
33208 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33209 #else
33210 # ifndef SWIG_STATIC_RUNTIME
33211 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33212 # endif
33213 #endif
33214 for (i = 0; swig_types_initial[i]; i++) {
33215 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33216 }
33217 typeinit = 1;
33218 }
33219 SWIG_InstallConstants(d,swig_const_table);
33220
33221 {
33222 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33223 }
33224 {
33225 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33226 }
33227 {
33228 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33229 }
33230 {
33231 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33232 }
33233 {
33234 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33235 }
33236 {
33237 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33238 }
33239 {
33240 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33241 }
33242 {
33243 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33244 }
33245 {
33246 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33247 }
33248 {
33249 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33250 }
33251 {
33252 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33493 }
33494 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33495 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33496 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33497 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33498 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33499 {
33500 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33501 }
33502 {
33503 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33504 }
33505 {
33506 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33507 }
33508 {
33509 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33510 }
33511 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33512
33513 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33514
33515 {
33516 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33523 }
33524 {
33525 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33526 }
33527 {
33528 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33529 }
33530 {
33531 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33532 }
33533 {
33534 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33535 }
33536 {
33537 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33538 }
33539 {
33540 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33541 }
33542 {
33543 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33544 }
33545 {
33546 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33547 }
33548 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33549 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33550 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33551 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33552 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33553 {
33554 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33555 }
33556 {
33557 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33558 }
33559 {
33560 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33561 }
33562 {
33563 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33564 }
33565 {
33566 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33567 }
33568 {
33569 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33570 }
33571 {
33572 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33573 }
33574 {
33575 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33576 }
33577 {
33578 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33579 }
33580 {
33581 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33582 }
33583 {
33584 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33645 }
33646 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33647 {
33648 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33649 }
33650 {
33651 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33652 }
33653 {
33654 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33655 }
33656 {
33657 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33658 }
33659 {
33660 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33661 }
33662
33663 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33664
33665 {
33666 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33667 }
33668 {
33669 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33670 }
33671 {
33672 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33673 }
33674 {
33675 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33676 }
33677 {
33678 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33685 }
33686 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33687 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33688 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33689 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33690 {
33691 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33692 }
33693 {
33694 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33695 }
33696 {
33697 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33698 }
33699 {
33700 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33701 }
33702 {
33703 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33704 }
33705 {
33706 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33707 }
33708 {
33709 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33710 }
33711 {
33712 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33713 }
33714 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33715 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33716 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33717 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33718 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33719 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33720 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33721 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33722 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33723 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33724 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33725 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33726 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33727 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33728 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33729 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33730 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33731 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33732 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33733 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33734 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33735 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33736 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33737 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33738 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33739 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33740 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33741 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33742 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33743 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33744 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33745 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33749 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33750 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33751 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33752 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33753 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33754 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33755 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33756 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33757 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33758 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33759 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33760 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33761 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33762 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33763 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33764 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33765 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33766 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33769 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33770
33771 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33772
33773 {
33774 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33775 }
33776 {
33777 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33778 }
33779 {
33780 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33781 }
33782 {
33783 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33784 }
33785 {
33786 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33787 }
33788 {
33789 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33790 }
33791 {
33792 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33793 }
33794 {
33795 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33796 }
33797 {
33798 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33799 }
33800 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33801 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33802 {
33803 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33804 }
33805 {
33806 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33807 }
33808 {
33809 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33810 }
33811 {
33812 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33813 }
33814 {
33815 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33816 }
33817 {
33818 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33819 }
33820 {
33821 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33822 }
33823 {
33824 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33825 }
33826 {
33827 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33828 }
33829 {
33830 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33831 }
33832 {
33833 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34266 }
34267 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34268 {
34269 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34270 }
34271 {
34272 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34273 }
34274 {
34275 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34276 }
34277 {
34278 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34279 }
34280 {
34281 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34282 }
34283 {
34284 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34285 }
34286 {
34287 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34288 }
34289 {
34290 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34291 }
34292 {
34293 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34294 }
34295 {
34296 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34297 }
34298 {
34299 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34327 }
34328 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34329 {
34330 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34331 }
34332 {
34333 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34334 }
34335 {
34336 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34337 }
34338 {
34339 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34340 }
34341 {
34342 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34343 }
34344 {
34345 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34346 }
34347 {
34348 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34349 }
34350 {
34351 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34352 }
34353 {
34354 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34355 }
34356 {
34357 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34358 }
34359 {
34360 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34364 }
34365
34366 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34367 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34368 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34369 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34370
34371 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34372 }
34373
wxWidgets (Impactor)