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


b1a16e7d843aba5bfcc5182cc34fcea7c47cde2e
[wxWidgets.git] / wxPython / src / msw / _misc_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLogChain swig_types[0]
1342 #define SWIGTYPE_p_wxMutexGuiLocker swig_types[1]
1343 #define SWIGTYPE_p_wxMetafile swig_types[2]
1344 #define SWIGTYPE_p_wxFileHistory swig_types[3]
1345 #define SWIGTYPE_p_wxLog swig_types[4]
1346 #define SWIGTYPE_p_wxMenu swig_types[5]
1347 #define SWIGTYPE_p_wxEvent swig_types[6]
1348 #define SWIGTYPE_p_wxDateTime__TimeZone swig_types[7]
1349 #define SWIGTYPE_p_wxConfigBase swig_types[8]
1350 #define SWIGTYPE_p_wxDisplay swig_types[9]
1351 #define SWIGTYPE_p_wxFileType swig_types[10]
1352 #define SWIGTYPE_p_wxLogGui swig_types[11]
1353 #define SWIGTYPE_p_wxFont swig_types[12]
1354 #define SWIGTYPE_p_wxDataFormat swig_types[13]
1355 #define SWIGTYPE_p_wxTimerEvent swig_types[14]
1356 #define SWIGTYPE_p_wxCaret swig_types[15]
1357 #define SWIGTYPE_ptrdiff_t swig_types[16]
1358 #define SWIGTYPE_std__ptrdiff_t swig_types[17]
1359 #define SWIGTYPE_p_int swig_types[18]
1360 #define SWIGTYPE_p_wxSize swig_types[19]
1361 #define SWIGTYPE_p_wxClipboard swig_types[20]
1362 #define SWIGTYPE_p_wxStopWatch swig_types[21]
1363 #define SWIGTYPE_p_wxDC swig_types[22]
1364 #define SWIGTYPE_p_wxClipboardLocker swig_types[23]
1365 #define SWIGTYPE_p_wxIcon swig_types[24]
1366 #define SWIGTYPE_p_wxLogStderr swig_types[25]
1367 #define SWIGTYPE_p_wxLogTextCtrl swig_types[26]
1368 #define SWIGTYPE_p_wxTextCtrl swig_types[27]
1369 #define SWIGTYPE_p_wxBusyCursor swig_types[28]
1370 #define SWIGTYPE_p_wxBitmapDataObject swig_types[29]
1371 #define SWIGTYPE_p_wxTextDataObject swig_types[30]
1372 #define SWIGTYPE_p_wxDataObject swig_types[31]
1373 #define SWIGTYPE_p_wxPyTextDataObject swig_types[32]
1374 #define SWIGTYPE_p_wxPyBitmapDataObject swig_types[33]
1375 #define SWIGTYPE_p_wxFileDataObject swig_types[34]
1376 #define SWIGTYPE_p_wxCustomDataObject swig_types[35]
1377 #define SWIGTYPE_p_wxURLDataObject swig_types[36]
1378 #define SWIGTYPE_p_wxMetafileDataObject swig_types[37]
1379 #define SWIGTYPE_p_wxSound swig_types[38]
1380 #define SWIGTYPE_p_wxTimerRunner swig_types[39]
1381 #define SWIGTYPE_p_wxLogWindow swig_types[40]
1382 #define SWIGTYPE_p_wxTimeSpan swig_types[41]
1383 #define SWIGTYPE_p_wxArrayString swig_types[42]
1384 #define SWIGTYPE_p_wxWindowDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxToolTip swig_types[45]
1387 #define SWIGTYPE_p_wxDataObjectComposite swig_types[46]
1388 #define SWIGTYPE_p_wxSystemSettings swig_types[47]
1389 #define SWIGTYPE_p_wxFileConfig swig_types[48]
1390 #define SWIGTYPE_p_wxVideoMode swig_types[49]
1391 #define SWIGTYPE_p_wxDataObjectSimple swig_types[50]
1392 #define SWIGTYPE_p_wxPyDataObjectSimple swig_types[51]
1393 #define SWIGTYPE_p_wxDuplexMode swig_types[52]
1394 #define SWIGTYPE_p_wxEvtHandler swig_types[53]
1395 #define SWIGTYPE_p_wxRect swig_types[54]
1396 #define SWIGTYPE_p_char swig_types[55]
1397 #define SWIGTYPE_p_wxSingleInstanceChecker swig_types[56]
1398 #define SWIGTYPE_p_wxStandardPaths swig_types[57]
1399 #define SWIGTYPE_p_wxFileTypeInfo swig_types[58]
1400 #define SWIGTYPE_p_wxFrame swig_types[59]
1401 #define SWIGTYPE_p_wxTimer swig_types[60]
1402 #define SWIGTYPE_p_wxPaperSize swig_types[61]
1403 #define SWIGTYPE_p_wxMimeTypesManager swig_types[62]
1404 #define SWIGTYPE_p_wxPyArtProvider swig_types[63]
1405 #define SWIGTYPE_p_wxPyTipProvider swig_types[64]
1406 #define SWIGTYPE_p_wxTipProvider swig_types[65]
1407 #define SWIGTYPE_p_wxJoystick swig_types[66]
1408 #define SWIGTYPE_p_wxSystemOptions swig_types[67]
1409 #define SWIGTYPE_p_wxPoint swig_types[68]
1410 #define SWIGTYPE_p_wxJoystickEvent swig_types[69]
1411 #define SWIGTYPE_p_wxCursor swig_types[70]
1412 #define SWIGTYPE_p_wxObject swig_types[71]
1413 #define SWIGTYPE_p_wxOutputStream swig_types[72]
1414 #define SWIGTYPE_p_wxDateTime swig_types[73]
1415 #define SWIGTYPE_p_wxPyDropSource swig_types[74]
1416 #define SWIGTYPE_p_unsigned_long swig_types[75]
1417 #define SWIGTYPE_p_wxKillError swig_types[76]
1418 #define SWIGTYPE_p_wxWindow swig_types[77]
1419 #define SWIGTYPE_p_wxString swig_types[78]
1420 #define SWIGTYPE_p_wxPyProcess swig_types[79]
1421 #define SWIGTYPE_p_wxBitmap swig_types[80]
1422 #define SWIGTYPE_p_wxConfig swig_types[81]
1423 #define SWIGTYPE_unsigned_int swig_types[82]
1424 #define SWIGTYPE_p_unsigned_int swig_types[83]
1425 #define SWIGTYPE_p_unsigned_char swig_types[84]
1426 #define SWIGTYPE_p_wxChar swig_types[85]
1427 #define SWIGTYPE_p_wxBusyInfo swig_types[86]
1428 #define SWIGTYPE_p_wxPyDropTarget swig_types[87]
1429 #define SWIGTYPE_p_wxPyTextDropTarget swig_types[88]
1430 #define SWIGTYPE_p_wxPyFileDropTarget swig_types[89]
1431 #define SWIGTYPE_p_wxProcessEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPyLog swig_types[91]
1433 #define SWIGTYPE_p_wxLogNull swig_types[92]
1434 #define SWIGTYPE_p_wxColour swig_types[93]
1435 #define SWIGTYPE_p_wxPyTimer swig_types[94]
1436 #define SWIGTYPE_p_wxConfigPathChanger swig_types[95]
1437 #define SWIGTYPE_p_wxDateSpan swig_types[96]
1438 static swig_type_info *swig_types[98];
1439
1440 /* -------- TYPES TABLE (END) -------- */
1441
1442
1443 /*-----------------------------------------------
1444 @(target):= _misc_.so
1445 ------------------------------------------------*/
1446 #define SWIG_init init_misc_
1447
1448 #define SWIG_name "_misc_"
1449
1450 #include "wx/wxPython/wxPython.h"
1451 #include "wx/wxPython/pyclasses.h"
1452 #include "wx/wxPython/pyistream.h"
1453
1454 static const wxString wxPyEmptyString(wxEmptyString);
1455
1456
1457
1458 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1459 #define SWIG_From_int PyInt_FromLong
1460 /*@@*/
1461
1462
1463 #include <limits.h>
1464
1465
1466 SWIGINTERN int
1467 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1468 const char *errmsg)
1469 {
1470 if (value < min_value) {
1471 if (errmsg) {
1472 PyErr_Format(PyExc_OverflowError,
1473 "value %ld is less than '%s' minimum %ld",
1474 value, errmsg, min_value);
1475 }
1476 return 0;
1477 } else if (value > max_value) {
1478 if (errmsg) {
1479 PyErr_Format(PyExc_OverflowError,
1480 "value %ld is greater than '%s' maximum %ld",
1481 value, errmsg, max_value);
1482 }
1483 return 0;
1484 }
1485 return 1;
1486 }
1487
1488
1489 SWIGINTERN int
1490 SWIG_AsVal_long(PyObject* obj, long* val)
1491 {
1492 if (PyNumber_Check(obj)) {
1493 if (val) *val = PyInt_AsLong(obj);
1494 return 1;
1495 }
1496 else {
1497 SWIG_type_error("number", obj);
1498 }
1499 return 0;
1500 }
1501
1502
1503 #if INT_MAX != LONG_MAX
1504 SWIGINTERN int
1505 SWIG_AsVal_int(PyObject *obj, int *val)
1506 {
1507 const char* errmsg = val ? "int" : (char*)0;
1508 long v;
1509 if (SWIG_AsVal_long(obj, &v)) {
1510 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1511 if (val) *val = (int)(v);
1512 return 1;
1513 } else {
1514 return 0;
1515 }
1516 } else {
1517 PyErr_Clear();
1518 }
1519 if (val) {
1520 SWIG_type_error(errmsg, obj);
1521 }
1522 return 0;
1523 }
1524 #else
1525 SWIGINTERNSHORT int
1526 SWIG_AsVal_int(PyObject *obj, int *val)
1527 {
1528 return SWIG_AsVal_long(obj,(long*)val);
1529 }
1530 #endif
1531
1532
1533 SWIGINTERNSHORT int
1534 SWIG_As_int(PyObject* obj)
1535 {
1536 int v;
1537 if (!SWIG_AsVal_int(obj, &v)) {
1538 /*
1539 this is needed to make valgrind/purify happier.
1540 */
1541 memset((void*)&v, 0, sizeof(int));
1542 }
1543 return v;
1544 }
1545
1546
1547 SWIGINTERNSHORT int
1548 SWIG_Check_int(PyObject* obj)
1549 {
1550 return SWIG_AsVal_int(obj, (int*)0);
1551 }
1552
1553 static const wxString wxPyWINDOW_DEFAULT_VARIANT(wxWINDOW_DEFAULT_VARIANT);
1554
1555 #include <wx/stockitem.h>
1556
1557 static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
1558 static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
1559 static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
1560
1561 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1562 #define SWIG_From_long PyInt_FromLong
1563 /*@@*/
1564
1565
1566 SWIGINTERNSHORT long
1567 SWIG_As_long(PyObject* obj)
1568 {
1569 long v;
1570 if (!SWIG_AsVal_long(obj, &v)) {
1571 /*
1572 this is needed to make valgrind/purify happier.
1573 */
1574 memset((void*)&v, 0, sizeof(long));
1575 }
1576 return v;
1577 }
1578
1579
1580 SWIGINTERNSHORT int
1581 SWIG_Check_long(PyObject* obj)
1582 {
1583 return SWIG_AsVal_long(obj, (long*)0);
1584 }
1585
1586
1587 SWIGINTERN int
1588 SWIG_AsVal_bool(PyObject *obj, bool *val)
1589 {
1590 if (obj == Py_True) {
1591 if (val) *val = true;
1592 return 1;
1593 }
1594 if (obj == Py_False) {
1595 if (val) *val = false;
1596 return 1;
1597 }
1598 int res = 0;
1599 if (SWIG_AsVal_int(obj, &res)) {
1600 if (val) *val = res ? true : false;
1601 return 1;
1602 } else {
1603 PyErr_Clear();
1604 }
1605 if (val) {
1606 SWIG_type_error("bool", obj);
1607 }
1608 return 0;
1609 }
1610
1611
1612 SWIGINTERNSHORT bool
1613 SWIG_As_bool(PyObject* obj)
1614 {
1615 bool v;
1616 if (!SWIG_AsVal_bool(obj, &v)) {
1617 /*
1618 this is needed to make valgrind/purify happier.
1619 */
1620 memset((void*)&v, 0, sizeof(bool));
1621 }
1622 return v;
1623 }
1624
1625
1626 SWIGINTERNSHORT int
1627 SWIG_Check_bool(PyObject* obj)
1628 {
1629 return SWIG_AsVal_bool(obj, (bool*)0);
1630 }
1631
1632
1633 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1634 PyObject* o2;
1635 PyObject* o3;
1636
1637 if (!target) {
1638 target = o;
1639 } else if (target == Py_None) {
1640 Py_DECREF(Py_None);
1641 target = o;
1642 } else {
1643 if (!PyTuple_Check(target)) {
1644 o2 = target;
1645 target = PyTuple_New(1);
1646 PyTuple_SetItem(target, 0, o2);
1647 }
1648 o3 = PyTuple_New(1);
1649 PyTuple_SetItem(o3, 0, o);
1650
1651 o2 = target;
1652 target = PySequence_Concat(o2, o3);
1653 Py_DECREF(o2);
1654 Py_DECREF(o3);
1655 }
1656 return target;
1657 }
1658
1659
1660
1661 SWIGINTERN int
1662 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
1663 {
1664 long v = 0;
1665 if (SWIG_AsVal_long(obj, &v) && v < 0) {
1666 SWIG_type_error("unsigned number", obj);
1667 }
1668 else if (val)
1669 *val = (unsigned long)v;
1670 return 1;
1671 }
1672
1673
1674 SWIGINTERNSHORT unsigned long
1675 SWIG_As_unsigned_SS_long(PyObject* obj)
1676 {
1677 unsigned long v;
1678 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1679 /*
1680 this is needed to make valgrind/purify happier.
1681 */
1682 memset((void*)&v, 0, sizeof(unsigned long));
1683 }
1684 return v;
1685 }
1686
1687
1688 SWIGINTERNSHORT int
1689 SWIG_Check_unsigned_SS_long(PyObject* obj)
1690 {
1691 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
1692 }
1693
1694
1695 SWIGINTERNSHORT PyObject*
1696 SWIG_From_unsigned_SS_long(unsigned long value)
1697 {
1698 return (value > LONG_MAX) ?
1699 PyLong_FromUnsignedLong(value)
1700 : PyInt_FromLong((long)(value));
1701 }
1702
1703
1704 bool wxThread_IsMain() {
1705 #ifdef WXP_WITH_THREAD
1706 return wxThread::IsMain();
1707 #else
1708 return true;
1709 #endif
1710 }
1711
1712 static void wxCaret_Destroy(wxCaret *self){
1713 delete self;
1714 }
1715
1716 #include <wx/snglinst.h>
1717
1718
1719 #ifdef __WXMSW__
1720 #include <wx/msw/private.h>
1721 #include <wx/dynload.h>
1722 #endif
1723
1724
1725
1726 bool wxDrawWindowOnDC(wxWindow* window, const wxDC& dc
1727 #if 0
1728 , int method
1729 #endif
1730 )
1731 {
1732 #ifdef __WXMSW__
1733 #if 0
1734 switch (method)
1735 {
1736 case 1:
1737 // This one only partially works. Appears to be an undocumented
1738 // "standard" convention that not all widgets adhear to. For
1739 // example, for some widgets backgrounds or non-client areas may
1740 // not be painted.
1741 ::SendMessage(GetHwndOf(window), WM_PAINT, (long)GetHdcOf(dc), 0);
1742 break;
1743
1744 case 2:
1745 #endif
1746 // This one works much better, nearly all widgets and their
1747 // children are captured correctly[**]. Prior to the big
1748 // background erase changes that Vadim did in 2004-2005 this
1749 // method failed badly on XP with Themes activated, most native
1750 // widgets draw only partially, if at all. Without themes it
1751 // worked just like on Win2k. After those changes this method
1752 // works very well.
1753 //
1754 // ** For example the radio buttons in a wxRadioBox are not its
1755 // children by default, but you can capture it via the panel
1756 // instead, or change RADIOBTN_PARENT_IS_RADIOBOX in radiobox.cpp.
1757 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1758 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1759 PRF_ERASEBKGND | PRF_OWNED );
1760 return true;
1761 #if 0
1762 break;
1763
1764 case 3:
1765 // This one is only defined in the latest SDK and is only
1766 // available on XP. MSDN says it is similar to sending WM_PRINT
1767 // so I expect that it will work similar to the above. Since it
1768 // is avaialble only on XP, it can't be compiled like this and
1769 // will have to be loaded dynamically.
1770 // //::PrintWindow(GetHwndOf(window), GetHdcOf(dc), 0); //break;
1771
1772 // fall through
1773
1774 case 4:
1775 // Use PrintWindow if available, or fallback to WM_PRINT
1776 // otherwise. Unfortunately using PrintWindow is even worse than
1777 // WM_PRINT. For most native widgets nothing is drawn to the dc
1778 // at all, with or without Themes.
1779 typedef BOOL (WINAPI *PrintWindow_t)(HWND, HDC, UINT);
1780 static bool s_triedToLoad = false;
1781 static PrintWindow_t pfnPrintWindow = NULL;
1782 if ( !s_triedToLoad )
1783 {
1784
1785 s_triedToLoad = true;
1786 wxDynamicLibrary dllUser32(_T("user32.dll"));
1787 if ( dllUser32.IsLoaded() )
1788 {
1789 wxLogNull nolog; // Don't report errors here
1790 pfnPrintWindow = (PrintWindow_t)dllUser32.GetSymbol(_T("PrintWindow"));
1791 }
1792 }
1793 if (pfnPrintWindow)
1794 {
1795 //printf("Using PrintWindow\n");
1796 pfnPrintWindow(GetHwndOf(window), GetHdcOf(dc), 0);
1797 }
1798 else
1799 {
1800 //printf("Using WM_PRINT\n");
1801 ::SendMessage(GetHwndOf(window), WM_PRINT, (long)GetHdcOf(dc),
1802 PRF_CLIENT | PRF_NONCLIENT | PRF_CHILDREN |
1803 PRF_ERASEBKGND | PRF_OWNED );
1804 }
1805 }
1806 #endif // 0
1807 #else
1808 return false;
1809 #endif // __WXMSW__
1810 }
1811
1812
1813
1814 #include <wx/tipdlg.h>
1815
1816
1817 class wxPyTipProvider : public wxTipProvider {
1818 public:
1819 wxPyTipProvider(size_t currentTip)
1820 : wxTipProvider(currentTip) {}
1821
1822 DEC_PYCALLBACK_STRING__pure(GetTip);
1823 DEC_PYCALLBACK_STRING_STRING(PreprocessTip);
1824 PYPRIVATE;
1825 };
1826
1827 IMP_PYCALLBACK_STRING__pure( wxPyTipProvider, wxTipProvider, GetTip);
1828 IMP_PYCALLBACK_STRING_STRING(wxPyTipProvider, wxTipProvider, PreprocessTip);
1829
1830
1831 //IMP_PYCALLBACK__(wxPyTimer, wxTimer, Notify);
1832
1833 IMPLEMENT_ABSTRACT_CLASS(wxPyTimer, wxTimer);
1834
1835 wxPyTimer::wxPyTimer(wxEvtHandler *owner, int id)
1836 : wxTimer(owner, id)
1837 {
1838 if (owner == NULL) SetOwner(this);
1839 }
1840
1841
1842 void wxPyTimer::Notify() {
1843 bool found;
1844 bool blocked = wxPyBeginBlockThreads();
1845 if ((found = wxPyCBH_findCallback(m_myInst, "Notify")))
1846 wxPyCBH_callCallback(m_myInst, Py_BuildValue("()"));
1847 wxPyEndBlockThreads(blocked);
1848 if (! found)
1849 wxTimer::Notify();
1850 }
1851 void wxPyTimer::base_Notify() {
1852 wxTimer::Notify();
1853 }
1854
1855
1856
1857 SWIGINTERN PyObject *
1858 SWIG_FromCharPtr(const char* cptr)
1859 {
1860 if (cptr) {
1861 size_t size = strlen(cptr);
1862 if (size > INT_MAX) {
1863 return SWIG_NewPointerObj((char*)(cptr),
1864 SWIG_TypeQuery("char *"), 0);
1865 } else {
1866 if (size != 0) {
1867 return PyString_FromStringAndSize(cptr, size);
1868 } else {
1869 return PyString_FromString(cptr);
1870 }
1871 }
1872 }
1873 Py_INCREF(Py_None);
1874 return Py_None;
1875 }
1876
1877
1878 SWIGINTERNSHORT int
1879 SWIG_CheckUnsignedLongInRange(unsigned long value,
1880 unsigned long max_value,
1881 const char *errmsg)
1882 {
1883 if (value > max_value) {
1884 if (errmsg) {
1885 PyErr_Format(PyExc_OverflowError,
1886 "value %lu is greater than '%s' minimum %lu",
1887 value, errmsg, max_value);
1888 }
1889 return 0;
1890 }
1891 return 1;
1892 }
1893
1894
1895 #if UINT_MAX != ULONG_MAX
1896 SWIGINTERN int
1897 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1898 {
1899 const char* errmsg = val ? "unsigned int" : (char*)0;
1900 unsigned long v;
1901 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1902 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
1903 if (val) *val = (unsigned int)(v);
1904 return 1;
1905 }
1906 } else {
1907 PyErr_Clear();
1908 }
1909 if (val) {
1910 SWIG_type_error(errmsg, obj);
1911 }
1912 return 0;
1913 }
1914 #else
1915 SWIGINTERNSHORT unsigned int
1916 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
1917 {
1918 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
1919 }
1920 #endif
1921
1922
1923 SWIGINTERNSHORT unsigned int
1924 SWIG_As_unsigned_SS_int(PyObject* obj)
1925 {
1926 unsigned int v;
1927 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
1928 /*
1929 this is needed to make valgrind/purify happier.
1930 */
1931 memset((void*)&v, 0, sizeof(unsigned int));
1932 }
1933 return v;
1934 }
1935
1936
1937 SWIGINTERNSHORT int
1938 SWIG_Check_unsigned_SS_int(PyObject* obj)
1939 {
1940 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
1941 }
1942
1943 static wxString Log_TimeStamp(){
1944 wxString msg;
1945 wxLog::TimeStamp(&msg);
1946 return msg;
1947 }
1948 static void wxLog_Destroy(wxLog *self){ delete self; }
1949 // Make somce wrappers that double any % signs so they are 'escaped'
1950 void wxPyLogFatalError(const wxString& msg)
1951 {
1952 wxString m(msg);
1953 m.Replace(wxT("%"), wxT("%%"));
1954 wxLogFatalError(m);
1955 }
1956
1957 void wxPyLogError(const wxString& msg)
1958 {
1959 wxString m(msg);
1960 m.Replace(wxT("%"), wxT("%%"));
1961 wxLogError(m);
1962 }
1963
1964 void wxPyLogWarning(const wxString& msg)
1965 {
1966 wxString m(msg);
1967 m.Replace(wxT("%"), wxT("%%"));
1968 wxLogWarning(m);
1969 }
1970
1971 void wxPyLogMessage(const wxString& msg)
1972 {
1973 wxString m(msg);
1974 m.Replace(wxT("%"), wxT("%%"));
1975 wxLogMessage(m);
1976 }
1977
1978 void wxPyLogInfo(const wxString& msg)
1979 {
1980 wxString m(msg);
1981 m.Replace(wxT("%"), wxT("%%"));
1982 wxLogInfo(m);
1983 }
1984
1985 void wxPyLogDebug(const wxString& msg)
1986 {
1987 wxString m(msg);
1988 m.Replace(wxT("%"), wxT("%%"));
1989 wxLogDebug(m);
1990 }
1991
1992 void wxPyLogVerbose(const wxString& msg)
1993 {
1994 wxString m(msg);
1995 m.Replace(wxT("%"), wxT("%%"));
1996 wxLogVerbose(m);
1997 }
1998
1999 void wxPyLogStatus(const wxString& msg)
2000 {
2001 wxString m(msg);
2002 m.Replace(wxT("%"), wxT("%%"));
2003 wxLogStatus(m);
2004 }
2005
2006 void wxPyLogStatusFrame(wxFrame *pFrame, const wxString& msg)
2007 {
2008 wxString m(msg);
2009 m.Replace(wxT("%"), wxT("%%"));
2010 wxLogStatus(pFrame, m);
2011 }
2012
2013 void wxPyLogSysError(const wxString& msg)
2014 {
2015 wxString m(msg);
2016 m.Replace(wxT("%"), wxT("%%"));
2017 wxLogSysError(m);
2018 }
2019
2020 void wxPyLogGeneric(unsigned long level, const wxString& msg)
2021 {
2022 wxString m(msg);
2023 m.Replace(wxT("%"), wxT("%%"));
2024 wxLogGeneric(level, m);
2025 }
2026
2027 void wxPyLogTrace(unsigned long mask, const wxString& msg)
2028 {
2029 wxString m(msg);
2030 m.Replace(wxT("%"), wxT("%%"));
2031 wxLogTrace(mask, m);
2032 }
2033
2034 void wxPyLogTrace(const wxString& mask, const wxString& msg)
2035 {
2036 wxString m(msg);
2037 m.Replace(wxT("%"), wxT("%%"));
2038 wxLogTrace(mask, m);
2039 }
2040
2041
2042
2043 // A wxLog class that can be derived from in wxPython
2044 class wxPyLog : public wxLog {
2045 public:
2046 wxPyLog() : wxLog() {}
2047
2048 virtual void DoLog(wxLogLevel level, const wxChar *szString, time_t t) {
2049 bool found;
2050 bool blocked = wxPyBeginBlockThreads();
2051 if ((found = wxPyCBH_findCallback(m_myInst, "DoLog"))) {
2052 PyObject* s = wx2PyString(szString);
2053 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iOi)", level, s, t));
2054 Py_DECREF(s);
2055 }
2056 wxPyEndBlockThreads(blocked);
2057 if (! found)
2058 wxLog::DoLog(level, szString, t);
2059 }
2060
2061 virtual void DoLogString(const wxChar *szString, time_t t) {
2062 bool found;
2063 bool blocked = wxPyBeginBlockThreads();
2064 if ((found = wxPyCBH_findCallback(m_myInst, "DoLogString"))) {
2065 PyObject* s = wx2PyString(szString);
2066 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(Oi)", s, t));
2067 Py_DECREF(s);
2068 }
2069 wxPyEndBlockThreads(blocked);
2070 if (! found)
2071 wxLog::DoLogString(szString, t);
2072 }
2073
2074 PYPRIVATE;
2075 };
2076
2077
2078
2079
2080 IMP_PYCALLBACK_VOID_INTINT( wxPyProcess, wxProcess, OnTerminate);
2081
2082
2083 #include <wx/joystick.h>
2084
2085
2086 #if !wxUSE_JOYSTICK && !defined(__WXMSW__)
2087 // A C++ stub class for wxJoystick for platforms that don't have it.
2088 class wxJoystick : public wxObject {
2089 public:
2090 wxJoystick(int joystick = wxJOYSTICK1) {
2091 bool blocked = wxPyBeginBlockThreads();
2092 PyErr_SetString(PyExc_NotImplementedError,
2093 "wxJoystick is not available on this platform.");
2094 wxPyEndBlockThreads(blocked);
2095 }
2096 wxPoint GetPosition() { return wxPoint(-1,-1); }
2097 int GetZPosition() { return -1; }
2098 int GetButtonState() { return -1; }
2099 int GetPOVPosition() { return -1; }
2100 int GetPOVCTSPosition() { return -1; }
2101 int GetRudderPosition() { return -1; }
2102 int GetUPosition() { return -1; }
2103 int GetVPosition() { return -1; }
2104 int GetMovementThreshold() { return -1; }
2105 void SetMovementThreshold(int threshold) {}
2106
2107 bool IsOk(void) { return false; }
2108 int GetNumberJoysticks() { return -1; }
2109 int GetManufacturerId() { return -1; }
2110 int GetProductId() { return -1; }
2111 wxString GetProductName() { return wxEmptyString; }
2112 int GetXMin() { return -1; }
2113 int GetYMin() { return -1; }
2114 int GetZMin() { return -1; }
2115 int GetXMax() { return -1; }
2116 int GetYMax() { return -1; }
2117 int GetZMax() { return -1; }
2118 int GetNumberButtons() { return -1; }
2119 int GetNumberAxes() { return -1; }
2120 int GetMaxButtons() { return -1; }
2121 int GetMaxAxes() { return -1; }
2122 int GetPollingMin() { return -1; }
2123 int GetPollingMax() { return -1; }
2124 int GetRudderMin() { return -1; }
2125 int GetRudderMax() { return -1; }
2126 int GetUMin() { return -1; }
2127 int GetUMax() { return -1; }
2128 int GetVMin() { return -1; }
2129 int GetVMax() { return -1; }
2130
2131 bool HasRudder() { return false; }
2132 bool HasZ() { return false; }
2133 bool HasU() { return false; }
2134 bool HasV() { return false; }
2135 bool HasPOV() { return false; }
2136 bool HasPOV4Dir() { return false; }
2137 bool HasPOVCTS() { return false; }
2138
2139 bool SetCapture(wxWindow* win, int pollingFreq = 0) { return false; }
2140 bool ReleaseCapture() { return false; }
2141 };
2142 #endif
2143
2144
2145 #include <wx/sound.h>
2146
2147
2148 #if !wxUSE_SOUND
2149 // A C++ stub class for wxWave for platforms that don't have it.
2150 class wxSound : public wxObject
2151 {
2152 public:
2153 wxSound() {
2154 bool blocked = wxPyBeginBlockThreads();
2155 PyErr_SetString(PyExc_NotImplementedError,
2156 "wxSound is not available on this platform.");
2157 wxPyEndBlockThreads(blocked);
2158 }
2159 wxSound(const wxString&/*, bool*/) {
2160 bool blocked = wxPyBeginBlockThreads();
2161 PyErr_SetString(PyExc_NotImplementedError,
2162 "wxSound is not available on this platform.");
2163 wxPyEndBlockThreads(blocked);
2164 }
2165 wxSound(int, const wxByte*) {
2166 bool blocked = wxPyBeginBlockThreads();
2167 PyErr_SetString(PyExc_NotImplementedError,
2168 "wxSound is not available on this platform.");
2169 wxPyEndBlockThreads(blocked);
2170 }
2171
2172 ~wxSound() {};
2173
2174 bool Create(const wxString&/*, bool*/) { return false; }
2175 bool Create(int, const wxByte*) { return false; };
2176 bool IsOk() { return false; };
2177 bool Play(unsigned) const { return false; }
2178 static bool Play(const wxString&, unsigned) { return false; }
2179 static void Stop() {}
2180 };
2181
2182 #endif
2183
2184 static wxSound *new_wxSound(wxString const &fileName=wxPyEmptyString){
2185 if (fileName.Length() == 0)
2186 return new wxSound;
2187 else
2188 return new wxSound(fileName);
2189 }
2190 static wxSound *new_wxSound(PyObject *data){
2191 unsigned char* buffer; int size;
2192 wxSound *sound = NULL;
2193
2194 bool blocked = wxPyBeginBlockThreads();
2195 if (!PyArg_Parse(data, "t#", &buffer, &size))
2196 goto done;
2197 sound = new wxSound(size, buffer);
2198 done:
2199 wxPyEndBlockThreads(blocked);
2200 return sound;
2201 }
2202 static bool wxSound_CreateFromData(wxSound *self,PyObject *data){
2203 #ifndef __WXMAC__
2204 unsigned char* buffer;
2205 int size;
2206 bool rv = false;
2207
2208 bool blocked = wxPyBeginBlockThreads();
2209 if (!PyArg_Parse(data, "t#", &buffer, &size))
2210 goto done;
2211 rv = self->Create(size, buffer);
2212 done:
2213 wxPyEndBlockThreads(blocked);
2214 return rv;
2215 #else
2216 bool blocked = wxPyBeginBlockThreads();
2217 PyErr_SetString(PyExc_NotImplementedError,
2218 "Create from data is not available on this platform.");
2219 wxPyEndBlockThreads(blocked);
2220 return false;
2221 #endif
2222 }
2223
2224 #include <wx/mimetype.h>
2225
2226 static PyObject *wxFileType_GetMimeType(wxFileType *self){
2227 wxString str;
2228 if (self->GetMimeType(&str))
2229 return wx2PyString(str);
2230 else
2231 RETURN_NONE();
2232 }
2233 static PyObject *wxFileType_GetMimeTypes(wxFileType *self){
2234 wxArrayString arr;
2235 if (self->GetMimeTypes(arr))
2236 return wxArrayString2PyList_helper(arr);
2237 else
2238 RETURN_NONE();
2239 }
2240 static PyObject *wxFileType_GetExtensions(wxFileType *self){
2241 wxArrayString arr;
2242 if (self->GetExtensions(arr))
2243 return wxArrayString2PyList_helper(arr);
2244 else
2245 RETURN_NONE();
2246 }
2247 static wxIcon *wxFileType_GetIcon(wxFileType *self){
2248 wxIconLocation loc;
2249 if (self->GetIcon(&loc))
2250 return new wxIcon(loc);
2251 else
2252 return NULL;
2253 }
2254 static PyObject *wxFileType_GetIconInfo(wxFileType *self){
2255 wxIconLocation loc;
2256 if (self->GetIcon(&loc)) {
2257 wxString iconFile = loc.GetFileName();
2258 int iconIndex = -1;
2259
2260 iconIndex = loc.GetIndex();
2261
2262 // Make a tuple and put the values in it
2263 bool blocked = wxPyBeginBlockThreads();
2264 PyObject* tuple = PyTuple_New(3);
2265 PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(loc),
2266 wxT("wxIcon"), true));
2267 PyTuple_SetItem(tuple, 1, wx2PyString(iconFile));
2268 PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
2269 wxPyEndBlockThreads(blocked);
2270 return tuple;
2271 }
2272 else
2273 RETURN_NONE();
2274 }
2275 static PyObject *wxFileType_GetDescription(wxFileType *self){
2276 wxString str;
2277 if (self->GetDescription(&str))
2278 return wx2PyString(str);
2279 else
2280 RETURN_NONE();
2281 }
2282 static PyObject *wxFileType_GetOpenCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2283 wxString str;
2284 if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2285 return wx2PyString(str);
2286 else
2287 RETURN_NONE();
2288 }
2289 static PyObject *wxFileType_GetPrintCommand(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2290 wxString str;
2291 if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
2292 return wx2PyString(str);
2293 else
2294 RETURN_NONE();
2295 }
2296 static PyObject *wxFileType_GetAllCommands(wxFileType *self,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2297 wxArrayString verbs;
2298 wxArrayString commands;
2299 if (self->GetAllCommands(&verbs, &commands,
2300 wxFileType::MessageParameters(filename, mimetype))) {
2301 bool blocked = wxPyBeginBlockThreads();
2302 PyObject* tuple = PyTuple_New(2);
2303 PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
2304 PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
2305 wxPyEndBlockThreads(blocked);
2306 return tuple;
2307 }
2308 else
2309 RETURN_NONE();
2310 }
2311 static wxString FileType_ExpandCommand(wxString const &command,wxString const &filename,wxString const &mimetype=wxPyEmptyString){
2312 return wxFileType::ExpandCommand(command,
2313 wxFileType::MessageParameters(filename, mimetype));
2314 }
2315 static PyObject *wxMimeTypesManager_EnumAllFileTypes(wxMimeTypesManager *self){
2316 wxArrayString arr;
2317 self->EnumAllFileTypes(arr);
2318 return wxArrayString2PyList_helper(arr);
2319 }
2320
2321 #include <wx/artprov.h>
2322
2323 static const wxString wxPyART_TOOLBAR(wxART_TOOLBAR);
2324 static const wxString wxPyART_MENU(wxART_MENU);
2325 static const wxString wxPyART_FRAME_ICON(wxART_FRAME_ICON);
2326 static const wxString wxPyART_CMN_DIALOG(wxART_CMN_DIALOG);
2327 static const wxString wxPyART_HELP_BROWSER(wxART_HELP_BROWSER);
2328 static const wxString wxPyART_MESSAGE_BOX(wxART_MESSAGE_BOX);
2329 static const wxString wxPyART_BUTTON(wxART_BUTTON);
2330 static const wxString wxPyART_OTHER(wxART_OTHER);
2331 static const wxString wxPyART_ADD_BOOKMARK(wxART_ADD_BOOKMARK);
2332 static const wxString wxPyART_DEL_BOOKMARK(wxART_DEL_BOOKMARK);
2333 static const wxString wxPyART_HELP_SIDE_PANEL(wxART_HELP_SIDE_PANEL);
2334 static const wxString wxPyART_HELP_SETTINGS(wxART_HELP_SETTINGS);
2335 static const wxString wxPyART_HELP_BOOK(wxART_HELP_BOOK);
2336 static const wxString wxPyART_HELP_FOLDER(wxART_HELP_FOLDER);
2337 static const wxString wxPyART_HELP_PAGE(wxART_HELP_PAGE);
2338 static const wxString wxPyART_GO_BACK(wxART_GO_BACK);
2339 static const wxString wxPyART_GO_FORWARD(wxART_GO_FORWARD);
2340 static const wxString wxPyART_GO_UP(wxART_GO_UP);
2341 static const wxString wxPyART_GO_DOWN(wxART_GO_DOWN);
2342 static const wxString wxPyART_GO_TO_PARENT(wxART_GO_TO_PARENT);
2343 static const wxString wxPyART_GO_HOME(wxART_GO_HOME);
2344 static const wxString wxPyART_FILE_OPEN(wxART_FILE_OPEN);
2345 static const wxString wxPyART_FILE_SAVE(wxART_FILE_SAVE);
2346 static const wxString wxPyART_FILE_SAVE_AS(wxART_FILE_SAVE_AS);
2347 static const wxString wxPyART_PRINT(wxART_PRINT);
2348 static const wxString wxPyART_HELP(wxART_HELP);
2349 static const wxString wxPyART_TIP(wxART_TIP);
2350 static const wxString wxPyART_REPORT_VIEW(wxART_REPORT_VIEW);
2351 static const wxString wxPyART_LIST_VIEW(wxART_LIST_VIEW);
2352 static const wxString wxPyART_NEW_DIR(wxART_NEW_DIR);
2353 static const wxString wxPyART_HARDDISK(wxART_HARDDISK);
2354 static const wxString wxPyART_FLOPPY(wxART_FLOPPY);
2355 static const wxString wxPyART_CDROM(wxART_CDROM);
2356 static const wxString wxPyART_REMOVABLE(wxART_REMOVABLE);
2357 static const wxString wxPyART_FOLDER(wxART_FOLDER);
2358 static const wxString wxPyART_FOLDER_OPEN(wxART_FOLDER_OPEN);
2359 static const wxString wxPyART_GO_DIR_UP(wxART_GO_DIR_UP);
2360 static const wxString wxPyART_EXECUTABLE_FILE(wxART_EXECUTABLE_FILE);
2361 static const wxString wxPyART_NORMAL_FILE(wxART_NORMAL_FILE);
2362 static const wxString wxPyART_TICK_MARK(wxART_TICK_MARK);
2363 static const wxString wxPyART_CROSS_MARK(wxART_CROSS_MARK);
2364 static const wxString wxPyART_ERROR(wxART_ERROR);
2365 static const wxString wxPyART_QUESTION(wxART_QUESTION);
2366 static const wxString wxPyART_WARNING(wxART_WARNING);
2367 static const wxString wxPyART_INFORMATION(wxART_INFORMATION);
2368 static const wxString wxPyART_MISSING_IMAGE(wxART_MISSING_IMAGE);
2369 static const wxString wxPyART_COPY(wxART_COPY);
2370 static const wxString wxPyART_CUT(wxART_CUT);
2371 static const wxString wxPyART_PASTE(wxART_PASTE);
2372 static const wxString wxPyART_DELETE(wxART_DELETE);
2373 static const wxString wxPyART_UNDO(wxART_UNDO);
2374 static const wxString wxPyART_REDO(wxART_REDO);
2375 static const wxString wxPyART_QUIT(wxART_QUIT);
2376 static const wxString wxPyART_FIND(wxART_FIND);
2377 static const wxString wxPyART_FIND_AND_REPLACE(wxART_FIND_AND_REPLACE);
2378 // Python aware wxArtProvider
2379 class wxPyArtProvider : public wxArtProvider {
2380 public:
2381
2382 virtual wxBitmap CreateBitmap(const wxArtID& id,
2383 const wxArtClient& client,
2384 const wxSize& size) {
2385 wxBitmap rval = wxNullBitmap;
2386 bool blocked = wxPyBeginBlockThreads();
2387 if ((wxPyCBH_findCallback(m_myInst, "CreateBitmap"))) {
2388 PyObject* so = wxPyConstructObject((void*)&size, wxT("wxSize"), 0);
2389 PyObject* ro;
2390 wxBitmap* ptr;
2391 PyObject* s1, *s2;
2392 s1 = wx2PyString(id);
2393 s2 = wx2PyString(client);
2394 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("(OOO)", s1, s2, so));
2395 Py_DECREF(so);
2396 Py_DECREF(s1);
2397 Py_DECREF(s2);
2398 if (ro) {
2399 if (wxPyConvertSwigPtr(ro, (void**)&ptr, wxT("wxBitmap")))
2400 rval = *ptr;
2401 Py_DECREF(ro);
2402 }
2403 }
2404 wxPyEndBlockThreads(blocked);
2405 return rval;
2406 }
2407
2408 PYPRIVATE;
2409 };
2410
2411 static void wxPyArtProvider_Destroy(wxPyArtProvider *self){ delete self; }
2412
2413
2414
2415 static PyObject* __EnumerationHelper(bool flag, wxString& str, long index) {
2416 PyObject* ret = PyTuple_New(3);
2417 if (ret) {
2418 PyTuple_SET_ITEM(ret, 0, PyInt_FromLong(flag));
2419 PyTuple_SET_ITEM(ret, 1, wx2PyString(str));
2420 PyTuple_SET_ITEM(ret, 2, PyInt_FromLong(index));
2421 }
2422 return ret;
2423 }
2424
2425 static PyObject *wxConfigBase_GetFirstGroup(wxConfigBase *self){
2426 bool cont;
2427 long index = 0;
2428 wxString value;
2429
2430 cont = self->GetFirstGroup(value, index);
2431 return __EnumerationHelper(cont, value, index);
2432 }
2433 static PyObject *wxConfigBase_GetNextGroup(wxConfigBase *self,long index){
2434 bool cont;
2435 wxString value;
2436
2437 cont = self->GetNextGroup(value, index);
2438 return __EnumerationHelper(cont, value, index);
2439 }
2440 static PyObject *wxConfigBase_GetFirstEntry(wxConfigBase *self){
2441 bool cont;
2442 long index = 0;
2443 wxString value;
2444
2445 cont = self->GetFirstEntry(value, index);
2446 return __EnumerationHelper(cont, value, index);
2447 }
2448 static PyObject *wxConfigBase_GetNextEntry(wxConfigBase *self,long index){
2449 bool cont;
2450 wxString value;
2451
2452 cont = self->GetNextEntry(value, index);
2453 return __EnumerationHelper(cont, value, index);
2454 }
2455 static long wxConfigBase_ReadInt(wxConfigBase *self,wxString const &key,long defaultVal=0){
2456 long rv;
2457 self->Read(key, &rv, defaultVal);
2458 return rv;
2459 }
2460
2461 SWIGINTERN int
2462 SWIG_AsVal_double(PyObject *obj, double* val)
2463 {
2464 if (PyNumber_Check(obj)) {
2465 if (val) *val = PyFloat_AsDouble(obj);
2466 return 1;
2467 }
2468 else {
2469 SWIG_type_error("number", obj);
2470 }
2471 return 0;
2472 }
2473
2474
2475 SWIGINTERNSHORT double
2476 SWIG_As_double(PyObject* obj)
2477 {
2478 double v;
2479 if (!SWIG_AsVal_double(obj, &v)) {
2480 /*
2481 this is needed to make valgrind/purify happier.
2482 */
2483 memset((void*)&v, 0, sizeof(double));
2484 }
2485 return v;
2486 }
2487
2488
2489 SWIGINTERNSHORT int
2490 SWIG_Check_double(PyObject* obj)
2491 {
2492 return SWIG_AsVal_double(obj, (double*)0);
2493 }
2494
2495 static double wxConfigBase_ReadFloat(wxConfigBase *self,wxString const &key,double defaultVal=0.0){
2496 double rv;
2497 self->Read(key, &rv, defaultVal);
2498 return rv;
2499 }
2500
2501 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2502 #define SWIG_From_double PyFloat_FromDouble
2503 /*@@*/
2504
2505 static bool wxConfigBase_ReadBool(wxConfigBase *self,wxString const &key,bool defaultVal=false){
2506 bool rv;
2507 self->Read(key, &rv, defaultVal);
2508 return rv;
2509 }
2510
2511 #include <wx/datetime.h>
2512
2513 static const wxString wxPyDefaultDateTimeFormat(wxDefaultDateTimeFormat);
2514 static const wxString wxPyDefaultTimeSpanFormat(wxDefaultTimeSpanFormat);
2515
2516 #define LOCAL_TZ wxDateTime::Local
2517
2518 static PyObject *DateTime_GetAmPmStrings(){
2519 wxString am;
2520 wxString pm;
2521 wxDateTime::GetAmPmStrings(&am, &pm);
2522 bool blocked = wxPyBeginBlockThreads();
2523 PyObject* tup = PyTuple_New(2);
2524 PyTuple_SET_ITEM(tup, 0, wx2PyString(am));
2525 PyTuple_SET_ITEM(tup, 1, wx2PyString(pm));
2526 wxPyEndBlockThreads(blocked);
2527 return tup;
2528 }
2529
2530 #if UINT_MAX < LONG_MAX
2531 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2532 #define SWIG_From_unsigned_SS_int SWIG_From_long
2533 /*@@*/
2534 #else
2535 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2536 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2537 /*@@*/
2538 #endif
2539
2540 static wxDateTime wxDateTime___add____SWIG_0(wxDateTime *self,wxTimeSpan const &other){ return *self + other; }
2541 static wxDateTime wxDateTime___add____SWIG_1(wxDateTime *self,wxDateSpan const &other){ return *self + other; }
2542 static wxTimeSpan wxDateTime___sub____SWIG_0(wxDateTime *self,wxDateTime const &other){ return *self - other; }
2543 static wxDateTime wxDateTime___sub____SWIG_1(wxDateTime *self,wxTimeSpan const &other){ return *self - other; }
2544 static wxDateTime wxDateTime___sub____SWIG_2(wxDateTime *self,wxDateSpan const &other){ return *self - other; }
2545 static bool wxDateTime___lt__(wxDateTime *self,wxDateTime const *other){
2546 if (!other || !self->IsValid() || !other->IsValid()) return self < other;
2547 return (*self < *other);
2548 }
2549 static bool wxDateTime___le__(wxDateTime *self,wxDateTime const *other){
2550 if (!other || !self->IsValid() || !other->IsValid()) return self <= other;
2551 return (*self <= *other);
2552 }
2553 static bool wxDateTime___gt__(wxDateTime *self,wxDateTime const *other){
2554 if (!other || !self->IsValid() || !other->IsValid()) return self > other;
2555 return (*self > *other);
2556 }
2557 static bool wxDateTime___ge__(wxDateTime *self,wxDateTime const *other){
2558 if (!other || !self->IsValid() || !other->IsValid()) return self >= other;
2559 return (*self >= *other);
2560 }
2561 static bool wxDateTime___eq__(wxDateTime *self,wxDateTime const *other){
2562 if (!other || !self->IsValid() || !other->IsValid()) return self == other;
2563 return (*self == *other);
2564 }
2565 static bool wxDateTime___ne__(wxDateTime *self,wxDateTime const *other){
2566 if (!other || !self->IsValid() || !other->IsValid()) return self != other;
2567 return (*self != *other);
2568 }
2569 static int wxDateTime_ParseRfc822Date(wxDateTime *self,wxString const &date){
2570 const wxChar* rv;
2571 const wxChar* _date = date;
2572 rv = self->ParseRfc822Date(_date);
2573 if (rv == NULL) return -1;
2574 return rv - _date;
2575 }
2576 static int wxDateTime_ParseFormat(wxDateTime *self,wxString const &date,wxString const &format=wxPyDefaultDateTimeFormat,wxDateTime const &dateDef=wxDefaultDateTime){
2577 const wxChar* rv;
2578 const wxChar* _date = date;
2579 rv = self->ParseFormat(_date, format, dateDef);
2580 if (rv == NULL) return -1;
2581 return rv - _date;
2582 }
2583 static int wxDateTime_ParseDateTime(wxDateTime *self,wxString const &datetime){
2584 const wxChar* rv;
2585 const wxChar* _datetime = datetime;
2586 rv = self->ParseDateTime(_datetime);
2587 if (rv == NULL) return -1;
2588 return rv - _datetime;
2589 }
2590 static int wxDateTime_ParseDate(wxDateTime *self,wxString const &date){
2591 const wxChar* rv;
2592 const wxChar* _date = date;
2593 rv = self->ParseDate(_date);
2594 if (rv == NULL) return -1;
2595 return rv - _date;
2596 }
2597 static int wxDateTime_ParseTime(wxDateTime *self,wxString const &time){
2598 const wxChar* rv;
2599 const wxChar* _time = time;
2600 rv = self->ParseTime(_time);
2601 if (rv == NULL) return -1;
2602 return rv - _time;
2603 }
2604 static wxTimeSpan wxTimeSpan___add__(wxTimeSpan *self,wxTimeSpan const &other){ return *self + other; }
2605 static wxTimeSpan wxTimeSpan___sub__(wxTimeSpan *self,wxTimeSpan const &other){ return *self - other; }
2606 static wxTimeSpan wxTimeSpan___mul__(wxTimeSpan *self,int n){ return *self * n; }
2607 static wxTimeSpan wxTimeSpan___rmul__(wxTimeSpan *self,int n){ return n * *self; }
2608 static bool wxTimeSpan___lt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self < *other) : false; }
2609 static bool wxTimeSpan___le__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self <= *other) : false; }
2610 static bool wxTimeSpan___gt__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self > *other) : true; }
2611 static bool wxTimeSpan___ge__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self >= *other) : true; }
2612 static bool wxTimeSpan___eq__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self == *other) : false; }
2613 static bool wxTimeSpan___ne__(wxTimeSpan *self,wxTimeSpan const *other){ return other ? (*self != *other) : true; }
2614 static wxDateSpan wxDateSpan___add__(wxDateSpan *self,wxDateSpan const &other){ return *self + other; }
2615 static wxDateSpan wxDateSpan___sub__(wxDateSpan *self,wxDateSpan const &other){ return *self - other; }
2616 static wxDateSpan wxDateSpan___mul__(wxDateSpan *self,int n){ return *self * n; }
2617 static wxDateSpan wxDateSpan___rmul__(wxDateSpan *self,int n){ return n * *self; }
2618 static bool wxDateSpan___eq__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self == *other) : false; }
2619 static bool wxDateSpan___ne__(wxDateSpan *self,wxDateSpan const *other){ return other ? (*self != *other) : true; }
2620
2621 #include <wx/dataobj.h>
2622
2623 static PyObject *wxDataObject_GetAllFormats(wxDataObject *self,wxDataObject::Direction dir=wxDataObject::Get){
2624 size_t count = self->GetFormatCount(dir);
2625 wxDataFormat* formats = new wxDataFormat[count];
2626 self->GetAllFormats(formats, dir);
2627
2628 bool blocked = wxPyBeginBlockThreads();
2629 PyObject* list = PyList_New(count);
2630 for (size_t i=0; i<count; i++) {
2631 wxDataFormat* format = new wxDataFormat(formats[i]);
2632 PyObject* obj = wxPyConstructObject((void*)format, wxT("wxDataFormat"), true);
2633 PyList_Append(list, obj);
2634 Py_DECREF(obj);
2635 }
2636 wxPyEndBlockThreads(blocked);
2637 delete [] formats;
2638 return list;
2639 }
2640 static PyObject *wxDataObject_GetDataHere(wxDataObject *self,wxDataFormat const &format){
2641 PyObject* rval = NULL;
2642 size_t size = self->GetDataSize(format);
2643 bool blocked = wxPyBeginBlockThreads();
2644 if (size) {
2645 char* buf = new char[size];
2646 if (self->GetDataHere(format, buf))
2647 rval = PyString_FromStringAndSize(buf, size);
2648 delete [] buf;
2649 }
2650 if (! rval) {
2651 rval = Py_None;
2652 Py_INCREF(rval);
2653 }
2654 wxPyEndBlockThreads(blocked);
2655 return rval;
2656 }
2657 static bool wxDataObject_SetData(wxDataObject *self,wxDataFormat const &format,PyObject *data){
2658 bool rval;
2659 bool blocked = wxPyBeginBlockThreads();
2660 if (PyString_Check(data)) {
2661 rval = self->SetData(format, PyString_Size(data), PyString_AsString(data));
2662 }
2663 else {
2664 // raise a TypeError if not a string
2665 PyErr_SetString(PyExc_TypeError, "String expected.");
2666 rval = false;
2667 }
2668 wxPyEndBlockThreads(blocked);
2669 return rval;
2670 }
2671 static PyObject *wxDataObjectSimple_GetDataHere(wxDataObjectSimple *self){
2672 PyObject* rval = NULL;
2673 size_t size = self->GetDataSize();
2674 bool blocked = wxPyBeginBlockThreads();
2675 if (size) {
2676 char* buf = new char[size];
2677 if (self->GetDataHere(buf))
2678 rval = PyString_FromStringAndSize(buf, size);
2679 delete [] buf;
2680 }
2681 if (! rval) {
2682 rval = Py_None;
2683 Py_INCREF(rval);
2684 }
2685 wxPyEndBlockThreads(blocked);
2686 return rval;
2687 }
2688 static bool wxDataObjectSimple_SetData(wxDataObjectSimple *self,PyObject *data){
2689 bool rval;
2690 bool blocked = wxPyBeginBlockThreads();
2691 if (PyString_Check(data)) {
2692 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2693 }
2694 else {
2695 // raise a TypeError if not a string
2696 PyErr_SetString(PyExc_TypeError, "String expected.");
2697 rval = false;
2698 }
2699 wxPyEndBlockThreads(blocked);
2700 return rval;
2701 }
2702 // Create a new class for wxPython to use
2703 class wxPyDataObjectSimple : public wxDataObjectSimple {
2704 public:
2705 wxPyDataObjectSimple(const wxDataFormat& format = wxFormatInvalid)
2706 : wxDataObjectSimple(format) {}
2707
2708 DEC_PYCALLBACK_SIZET__const(GetDataSize);
2709 bool GetDataHere(void *buf) const;
2710 bool SetData(size_t len, const void *buf) const;
2711 PYPRIVATE;
2712 };
2713
2714 IMP_PYCALLBACK_SIZET__const(wxPyDataObjectSimple, wxDataObjectSimple, GetDataSize);
2715
2716 bool wxPyDataObjectSimple::GetDataHere(void *buf) const {
2717 // We need to get the data for this object and write it to buf. I think
2718 // the best way to do this for wxPython is to have the Python method
2719 // return either a string or None and then act appropriately with the
2720 // C++ version.
2721
2722 bool rval = false;
2723 bool blocked = wxPyBeginBlockThreads();
2724 if (wxPyCBH_findCallback(m_myInst, "GetDataHere")) {
2725 PyObject* ro;
2726 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2727 if (ro) {
2728 rval = (ro != Py_None && PyString_Check(ro));
2729 if (rval)
2730 memcpy(buf, PyString_AsString(ro), PyString_Size(ro));
2731 Py_DECREF(ro);
2732 }
2733 }
2734 wxPyEndBlockThreads(blocked);
2735 return rval;
2736 }
2737
2738 bool wxPyDataObjectSimple::SetData(size_t len, const void *buf) const{
2739 // For this one we simply need to make a string from buf and len
2740 // and send it to the Python method.
2741 bool rval = false;
2742 bool blocked = wxPyBeginBlockThreads();
2743 if (wxPyCBH_findCallback(m_myInst, "SetData")) {
2744 PyObject* data = PyString_FromStringAndSize((char*)buf, len);
2745 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", data));
2746 Py_DECREF(data);
2747 }
2748 wxPyEndBlockThreads(blocked);
2749 return rval;
2750 }
2751
2752 // Create a new class for wxPython to use
2753 class wxPyTextDataObject : public wxTextDataObject {
2754 public:
2755 wxPyTextDataObject(const wxString& text = wxPyEmptyString)
2756 : wxTextDataObject(text) {}
2757
2758 DEC_PYCALLBACK_SIZET__const(GetTextLength);
2759 DEC_PYCALLBACK_STRING__const(GetText);
2760 DEC_PYCALLBACK__STRING(SetText);
2761 PYPRIVATE;
2762 };
2763
2764 IMP_PYCALLBACK_SIZET__const(wxPyTextDataObject, wxTextDataObject, GetTextLength);
2765 IMP_PYCALLBACK_STRING__const(wxPyTextDataObject, wxTextDataObject, GetText);
2766 IMP_PYCALLBACK__STRING(wxPyTextDataObject, wxTextDataObject, SetText);
2767
2768
2769 // Create a new class for wxPython to use
2770 class wxPyBitmapDataObject : public wxBitmapDataObject {
2771 public:
2772 wxPyBitmapDataObject(const wxBitmap& bitmap = wxNullBitmap)
2773 : wxBitmapDataObject(bitmap) {}
2774
2775 wxBitmap GetBitmap() const;
2776 void SetBitmap(const wxBitmap& bitmap);
2777 PYPRIVATE;
2778 };
2779
2780 wxBitmap wxPyBitmapDataObject::GetBitmap() const {
2781 wxBitmap* rval = &wxNullBitmap;
2782 bool blocked = wxPyBeginBlockThreads();
2783 if (wxPyCBH_findCallback(m_myInst, "GetBitmap")) {
2784 PyObject* ro;
2785 wxBitmap* ptr;
2786 ro = wxPyCBH_callCallbackObj(m_myInst, Py_BuildValue("()"));
2787 if (ro) {
2788 if (wxPyConvertSwigPtr(ro, (void **)&ptr, wxT("wxBitmap")))
2789 rval = ptr;
2790 Py_DECREF(ro);
2791 }
2792 }
2793 wxPyEndBlockThreads(blocked);
2794 return *rval;
2795 }
2796
2797 void wxPyBitmapDataObject::SetBitmap(const wxBitmap& bitmap) {
2798 bool blocked = wxPyBeginBlockThreads();
2799 if (wxPyCBH_findCallback(m_myInst, "SetBitmap")) {
2800 PyObject* bo = wxPyConstructObject((void*)&bitmap, wxT("wxBitmap"), false);
2801 wxPyCBH_callCallback(m_myInst, Py_BuildValue("(O)", bo));
2802 Py_DECREF(bo);
2803 }
2804 wxPyEndBlockThreads(blocked);
2805 }
2806
2807 static wxCustomDataObject *new_wxCustomDataObject__SWIG_1(wxString const &formatName){
2808 return new wxCustomDataObject(wxDataFormat(formatName));
2809 }
2810 static bool wxCustomDataObject_SetData(wxCustomDataObject *self,PyObject *data){
2811 bool rval;
2812 bool blocked = wxPyBeginBlockThreads();
2813 if (PyString_Check(data)) {
2814 rval = self->SetData(PyString_Size(data), PyString_AsString(data));
2815 }
2816 else {
2817 // raise a TypeError if not a string
2818 PyErr_SetString(PyExc_TypeError, "String expected.");
2819 rval = false;
2820 }
2821 wxPyEndBlockThreads(blocked);
2822 return rval;
2823 }
2824 static PyObject *wxCustomDataObject_GetData(wxCustomDataObject *self){
2825 PyObject* obj;
2826 bool blocked = wxPyBeginBlockThreads();
2827 obj = PyString_FromStringAndSize((char*)self->GetData(), self->GetSize());
2828 wxPyEndBlockThreads(blocked);
2829 return obj;
2830 }
2831
2832 #include <wx/metafile.h>
2833
2834
2835 IMP_PYCALLBACK_BOOL_DR(wxPyDropSource, wxDropSource, GiveFeedback);
2836
2837
2838 IMP_PYCALLBACK__(wxPyDropTarget, wxDropTarget, OnLeave);
2839 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnEnter);
2840 IMP_PYCALLBACK_DR_2WXCDR(wxPyDropTarget, wxDropTarget, OnDragOver);
2841 IMP_PYCALLBACK_DR_2WXCDR_pure(wxPyDropTarget, wxDropTarget, OnData);
2842 IMP_PYCALLBACK_BOOL_INTINT(wxPyDropTarget, wxDropTarget, OnDrop);
2843
2844
2845 class wxPyTextDropTarget : public wxTextDropTarget {
2846 public:
2847 wxPyTextDropTarget() {}
2848
2849 DEC_PYCALLBACK_BOOL_INTINTSTR_pure(OnDropText);
2850
2851 DEC_PYCALLBACK__(OnLeave);
2852 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2853 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2854 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2855 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2856
2857 PYPRIVATE;
2858 };
2859
2860 IMP_PYCALLBACK_BOOL_INTINTSTR_pure(wxPyTextDropTarget, wxTextDropTarget, OnDropText);
2861 IMP_PYCALLBACK__(wxPyTextDropTarget, wxTextDropTarget, OnLeave);
2862 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnEnter);
2863 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnDragOver);
2864 IMP_PYCALLBACK_DR_2WXCDR(wxPyTextDropTarget, wxTextDropTarget, OnData);
2865 IMP_PYCALLBACK_BOOL_INTINT(wxPyTextDropTarget, wxTextDropTarget, OnDrop);
2866
2867
2868
2869 class wxPyFileDropTarget : public wxFileDropTarget {
2870 public:
2871 wxPyFileDropTarget() {}
2872
2873 virtual bool OnDropFiles(wxCoord x, wxCoord y, const wxArrayString& filenames);
2874
2875 DEC_PYCALLBACK__(OnLeave);
2876 DEC_PYCALLBACK_DR_2WXCDR(OnEnter);
2877 DEC_PYCALLBACK_DR_2WXCDR(OnDragOver);
2878 DEC_PYCALLBACK_DR_2WXCDR(OnData);
2879 DEC_PYCALLBACK_BOOL_INTINT(OnDrop);
2880
2881 PYPRIVATE;
2882 };
2883
2884 bool wxPyFileDropTarget::OnDropFiles(wxCoord x, wxCoord y,
2885 const wxArrayString& filenames) {
2886 bool rval = false;
2887 bool blocked = wxPyBeginBlockThreads();
2888 if (wxPyCBH_findCallback(m_myInst, "OnDropFiles")) {
2889 PyObject* list = wxArrayString2PyList_helper(filenames);
2890 rval = wxPyCBH_callCallback(m_myInst, Py_BuildValue("(iiO)",x,y,list));
2891 Py_DECREF(list);
2892 }
2893 wxPyEndBlockThreads(blocked);
2894 return rval;
2895 }
2896
2897
2898
2899 IMP_PYCALLBACK__(wxPyFileDropTarget, wxFileDropTarget, OnLeave);
2900 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnEnter);
2901 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnDragOver);
2902 IMP_PYCALLBACK_DR_2WXCDR(wxPyFileDropTarget, wxFileDropTarget, OnData);
2903 IMP_PYCALLBACK_BOOL_INTINT(wxPyFileDropTarget, wxFileDropTarget, OnDrop);
2904
2905
2906
2907
2908 static bool wxClipboardLocker___nonzero__(wxClipboardLocker *self){ return !!(*self); }
2909
2910 #include <wx/display.h>
2911
2912 static bool wxVideoMode___eq__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self == *other) : false; }
2913 static bool wxVideoMode___ne__(wxVideoMode *self,wxVideoMode const *other){ return other ? (*self != *other) : true; }
2914
2915 // dummy version of wxDisplay for when it is not enabled in the wxWidgets build
2916 #if !wxUSE_DISPLAY
2917 #include <wx/dynarray.h>
2918 #include <wx/vidmode.h>
2919
2920 WX_DECLARE_OBJARRAY(wxVideoMode, wxArrayVideoModes);
2921 #include "wx/arrimpl.cpp"
2922 WX_DEFINE_OBJARRAY(wxArrayVideoModes);
2923 const wxVideoMode wxDefaultVideoMode;
2924
2925 class wxDisplay
2926 {
2927 public:
2928 wxDisplay(size_t index = 0) { wxPyRaiseNotImplemented(); }
2929 ~wxDisplay() {}
2930
2931 static size_t GetCount()
2932 { wxPyRaiseNotImplemented(); return 0; }
2933
2934 static int GetFromPoint(const wxPoint& pt)
2935 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2936 static int GetFromWindow(wxWindow *window)
2937 { wxPyRaiseNotImplemented(); return wxNOT_FOUND; }
2938
2939 virtual bool IsOk() const { return false; }
2940 virtual wxRect GetGeometry() const { wxRect r; return r; }
2941 virtual wxString GetName() const { return wxEmptyString; }
2942 bool IsPrimary() const { return false; }
2943
2944 wxArrayVideoModes GetModes(const wxVideoMode& mode = wxDefaultVideoMode)
2945 { wxArrayVideoModes a; return a; }
2946
2947 virtual wxVideoMode GetCurrentMode() const
2948 { return wxDefaultVideoMode; }
2949
2950 virtual bool ChangeMode(const wxVideoMode& mode = wxDefaultVideoMode)
2951 { return false; }
2952
2953 void ResetMode() {}
2954 };
2955 #endif
2956
2957 static PyObject *wxDisplay_GetModes(wxDisplay *self,wxVideoMode const &mode=wxDefaultVideoMode){
2958 PyObject* pyList = NULL;
2959 wxArrayVideoModes arr = self->GetModes(mode);
2960 bool blocked = wxPyBeginBlockThreads();
2961 pyList = PyList_New(0);
2962 for (int i=0; i < arr.GetCount(); i++) {
2963 wxVideoMode* m = new wxVideoMode(arr.Item(i));
2964 PyObject* pyObj = wxPyConstructObject(m, wxT("wxVideoMode"), true);
2965 PyList_Append(pyList, pyObj);
2966 Py_DECREF(pyObj);
2967 }
2968 wxPyEndBlockThreads(blocked);
2969 return pyList;
2970 }
2971
2972 #include <wx/stdpaths.h>
2973
2974 static wxStandardPaths *StandardPaths_Get(){
2975 return (wxStandardPaths*) &wxStandardPaths::Get();
2976 }
2977 static void wxStandardPaths_SetInstallPrefix(wxStandardPaths *self,wxString const &prefix){}
2978 static wxString wxStandardPaths_GetInstallPrefix(wxStandardPaths *self){ return wxEmptyString; }
2979 #ifdef __cplusplus
2980 extern "C" {
2981 #endif
2982 static PyObject *_wrap_SystemSettings_GetColour(PyObject *, PyObject *args, PyObject *kwargs) {
2983 PyObject *resultobj;
2984 wxSystemColour arg1 ;
2985 wxColour result;
2986 PyObject * obj0 = 0 ;
2987 char *kwnames[] = {
2988 (char *) "index", NULL
2989 };
2990
2991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetColour",kwnames,&obj0)) goto fail;
2992 {
2993 arg1 = (wxSystemColour)(SWIG_As_int(obj0));
2994 if (SWIG_arg_fail(1)) SWIG_fail;
2995 }
2996 {
2997 if (!wxPyCheckForApp()) SWIG_fail;
2998 PyThreadState* __tstate = wxPyBeginAllowThreads();
2999 result = wxSystemSettings::GetColour((wxSystemColour )arg1);
3000
3001 wxPyEndAllowThreads(__tstate);
3002 if (PyErr_Occurred()) SWIG_fail;
3003 }
3004 {
3005 wxColour * resultptr;
3006 resultptr = new wxColour((wxColour &)(result));
3007 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
3008 }
3009 return resultobj;
3010 fail:
3011 return NULL;
3012 }
3013
3014
3015 static PyObject *_wrap_SystemSettings_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
3016 PyObject *resultobj;
3017 wxSystemFont arg1 ;
3018 wxFont result;
3019 PyObject * obj0 = 0 ;
3020 char *kwnames[] = {
3021 (char *) "index", NULL
3022 };
3023
3024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetFont",kwnames,&obj0)) goto fail;
3025 {
3026 arg1 = (wxSystemFont)(SWIG_As_int(obj0));
3027 if (SWIG_arg_fail(1)) SWIG_fail;
3028 }
3029 {
3030 if (!wxPyCheckForApp()) SWIG_fail;
3031 PyThreadState* __tstate = wxPyBeginAllowThreads();
3032 result = wxSystemSettings::GetFont((wxSystemFont )arg1);
3033
3034 wxPyEndAllowThreads(__tstate);
3035 if (PyErr_Occurred()) SWIG_fail;
3036 }
3037 {
3038 wxFont * resultptr;
3039 resultptr = new wxFont((wxFont &)(result));
3040 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
3041 }
3042 return resultobj;
3043 fail:
3044 return NULL;
3045 }
3046
3047
3048 static PyObject *_wrap_SystemSettings_GetMetric(PyObject *, PyObject *args, PyObject *kwargs) {
3049 PyObject *resultobj;
3050 wxSystemMetric arg1 ;
3051 int result;
3052 PyObject * obj0 = 0 ;
3053 char *kwnames[] = {
3054 (char *) "index", NULL
3055 };
3056
3057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_GetMetric",kwnames,&obj0)) goto fail;
3058 {
3059 arg1 = (wxSystemMetric)(SWIG_As_int(obj0));
3060 if (SWIG_arg_fail(1)) SWIG_fail;
3061 }
3062 {
3063 if (!wxPyCheckForApp()) SWIG_fail;
3064 PyThreadState* __tstate = wxPyBeginAllowThreads();
3065 result = (int)wxSystemSettings::GetMetric((wxSystemMetric )arg1);
3066
3067 wxPyEndAllowThreads(__tstate);
3068 if (PyErr_Occurred()) SWIG_fail;
3069 }
3070 {
3071 resultobj = SWIG_From_int((int)(result));
3072 }
3073 return resultobj;
3074 fail:
3075 return NULL;
3076 }
3077
3078
3079 static PyObject *_wrap_SystemSettings_HasFeature(PyObject *, PyObject *args, PyObject *kwargs) {
3080 PyObject *resultobj;
3081 wxSystemFeature arg1 ;
3082 bool result;
3083 PyObject * obj0 = 0 ;
3084 char *kwnames[] = {
3085 (char *) "index", NULL
3086 };
3087
3088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_HasFeature",kwnames,&obj0)) goto fail;
3089 {
3090 arg1 = (wxSystemFeature)(SWIG_As_int(obj0));
3091 if (SWIG_arg_fail(1)) SWIG_fail;
3092 }
3093 {
3094 if (!wxPyCheckForApp()) SWIG_fail;
3095 PyThreadState* __tstate = wxPyBeginAllowThreads();
3096 result = (bool)wxSystemSettings::HasFeature((wxSystemFeature )arg1);
3097
3098 wxPyEndAllowThreads(__tstate);
3099 if (PyErr_Occurred()) SWIG_fail;
3100 }
3101 {
3102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3103 }
3104 return resultobj;
3105 fail:
3106 return NULL;
3107 }
3108
3109
3110 static PyObject *_wrap_SystemSettings_GetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3111 PyObject *resultobj;
3112 wxSystemScreenType result;
3113 char *kwnames[] = {
3114 NULL
3115 };
3116
3117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SystemSettings_GetScreenType",kwnames)) goto fail;
3118 {
3119 if (!wxPyCheckForApp()) SWIG_fail;
3120 PyThreadState* __tstate = wxPyBeginAllowThreads();
3121 result = (wxSystemScreenType)wxSystemSettings::GetScreenType();
3122
3123 wxPyEndAllowThreads(__tstate);
3124 if (PyErr_Occurred()) SWIG_fail;
3125 }
3126 resultobj = SWIG_From_int((result));
3127 return resultobj;
3128 fail:
3129 return NULL;
3130 }
3131
3132
3133 static PyObject *_wrap_SystemSettings_SetScreenType(PyObject *, PyObject *args, PyObject *kwargs) {
3134 PyObject *resultobj;
3135 wxSystemScreenType arg1 ;
3136 PyObject * obj0 = 0 ;
3137 char *kwnames[] = {
3138 (char *) "screen", NULL
3139 };
3140
3141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemSettings_SetScreenType",kwnames,&obj0)) goto fail;
3142 {
3143 arg1 = (wxSystemScreenType)(SWIG_As_int(obj0));
3144 if (SWIG_arg_fail(1)) SWIG_fail;
3145 }
3146 {
3147 if (!wxPyCheckForApp()) SWIG_fail;
3148 PyThreadState* __tstate = wxPyBeginAllowThreads();
3149 wxSystemSettings::SetScreenType((wxSystemScreenType )arg1);
3150
3151 wxPyEndAllowThreads(__tstate);
3152 if (PyErr_Occurred()) SWIG_fail;
3153 }
3154 Py_INCREF(Py_None); resultobj = Py_None;
3155 return resultobj;
3156 fail:
3157 return NULL;
3158 }
3159
3160
3161 static PyObject * SystemSettings_swigregister(PyObject *, PyObject *args) {
3162 PyObject *obj;
3163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3164 SWIG_TypeClientData(SWIGTYPE_p_wxSystemSettings, obj);
3165 Py_INCREF(obj);
3166 return Py_BuildValue((char *)"");
3167 }
3168 static int _wrap_WINDOW_DEFAULT_VARIANT_set(PyObject *) {
3169 PyErr_SetString(PyExc_TypeError,"Variable WINDOW_DEFAULT_VARIANT is read-only.");
3170 return 1;
3171 }
3172
3173
3174 static PyObject *_wrap_WINDOW_DEFAULT_VARIANT_get(void) {
3175 PyObject *pyobj;
3176
3177 {
3178 #if wxUSE_UNICODE
3179 pyobj = PyUnicode_FromWideChar((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3180 #else
3181 pyobj = PyString_FromStringAndSize((&wxPyWINDOW_DEFAULT_VARIANT)->c_str(), (&wxPyWINDOW_DEFAULT_VARIANT)->Len());
3182 #endif
3183 }
3184 return pyobj;
3185 }
3186
3187
3188 static PyObject *_wrap_new_SystemOptions(PyObject *, PyObject *args, PyObject *kwargs) {
3189 PyObject *resultobj;
3190 wxSystemOptions *result;
3191 char *kwnames[] = {
3192 NULL
3193 };
3194
3195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SystemOptions",kwnames)) goto fail;
3196 {
3197 PyThreadState* __tstate = wxPyBeginAllowThreads();
3198 result = (wxSystemOptions *)new wxSystemOptions();
3199
3200 wxPyEndAllowThreads(__tstate);
3201 if (PyErr_Occurred()) SWIG_fail;
3202 }
3203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSystemOptions, 1);
3204 return resultobj;
3205 fail:
3206 return NULL;
3207 }
3208
3209
3210 static PyObject *_wrap_SystemOptions_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3211 PyObject *resultobj;
3212 wxString *arg1 = 0 ;
3213 wxString *arg2 = 0 ;
3214 bool temp1 = false ;
3215 bool temp2 = false ;
3216 PyObject * obj0 = 0 ;
3217 PyObject * obj1 = 0 ;
3218 char *kwnames[] = {
3219 (char *) "name",(char *) "value", NULL
3220 };
3221
3222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOption",kwnames,&obj0,&obj1)) goto fail;
3223 {
3224 arg1 = wxString_in_helper(obj0);
3225 if (arg1 == NULL) SWIG_fail;
3226 temp1 = true;
3227 }
3228 {
3229 arg2 = wxString_in_helper(obj1);
3230 if (arg2 == NULL) SWIG_fail;
3231 temp2 = true;
3232 }
3233 {
3234 PyThreadState* __tstate = wxPyBeginAllowThreads();
3235 wxSystemOptions::SetOption((wxString const &)*arg1,(wxString const &)*arg2);
3236
3237 wxPyEndAllowThreads(__tstate);
3238 if (PyErr_Occurred()) SWIG_fail;
3239 }
3240 Py_INCREF(Py_None); resultobj = Py_None;
3241 {
3242 if (temp1)
3243 delete arg1;
3244 }
3245 {
3246 if (temp2)
3247 delete arg2;
3248 }
3249 return resultobj;
3250 fail:
3251 {
3252 if (temp1)
3253 delete arg1;
3254 }
3255 {
3256 if (temp2)
3257 delete arg2;
3258 }
3259 return NULL;
3260 }
3261
3262
3263 static PyObject *_wrap_SystemOptions_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3264 PyObject *resultobj;
3265 wxString *arg1 = 0 ;
3266 int arg2 ;
3267 bool temp1 = false ;
3268 PyObject * obj0 = 0 ;
3269 PyObject * obj1 = 0 ;
3270 char *kwnames[] = {
3271 (char *) "name",(char *) "value", NULL
3272 };
3273
3274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SystemOptions_SetOptionInt",kwnames,&obj0,&obj1)) goto fail;
3275 {
3276 arg1 = wxString_in_helper(obj0);
3277 if (arg1 == NULL) SWIG_fail;
3278 temp1 = true;
3279 }
3280 {
3281 arg2 = (int)(SWIG_As_int(obj1));
3282 if (SWIG_arg_fail(2)) SWIG_fail;
3283 }
3284 {
3285 PyThreadState* __tstate = wxPyBeginAllowThreads();
3286 wxSystemOptions::SetOption((wxString const &)*arg1,arg2);
3287
3288 wxPyEndAllowThreads(__tstate);
3289 if (PyErr_Occurred()) SWIG_fail;
3290 }
3291 Py_INCREF(Py_None); resultobj = Py_None;
3292 {
3293 if (temp1)
3294 delete arg1;
3295 }
3296 return resultobj;
3297 fail:
3298 {
3299 if (temp1)
3300 delete arg1;
3301 }
3302 return NULL;
3303 }
3304
3305
3306 static PyObject *_wrap_SystemOptions_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
3307 PyObject *resultobj;
3308 wxString *arg1 = 0 ;
3309 wxString result;
3310 bool temp1 = false ;
3311 PyObject * obj0 = 0 ;
3312 char *kwnames[] = {
3313 (char *) "name", NULL
3314 };
3315
3316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOption",kwnames,&obj0)) goto fail;
3317 {
3318 arg1 = wxString_in_helper(obj0);
3319 if (arg1 == NULL) SWIG_fail;
3320 temp1 = true;
3321 }
3322 {
3323 PyThreadState* __tstate = wxPyBeginAllowThreads();
3324 result = wxSystemOptions::GetOption((wxString const &)*arg1);
3325
3326 wxPyEndAllowThreads(__tstate);
3327 if (PyErr_Occurred()) SWIG_fail;
3328 }
3329 {
3330 #if wxUSE_UNICODE
3331 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3332 #else
3333 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3334 #endif
3335 }
3336 {
3337 if (temp1)
3338 delete arg1;
3339 }
3340 return resultobj;
3341 fail:
3342 {
3343 if (temp1)
3344 delete arg1;
3345 }
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_SystemOptions_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxString *arg1 = 0 ;
3353 int result;
3354 bool temp1 = false ;
3355 PyObject * obj0 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "name", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_GetOptionInt",kwnames,&obj0)) goto fail;
3361 {
3362 arg1 = wxString_in_helper(obj0);
3363 if (arg1 == NULL) SWIG_fail;
3364 temp1 = true;
3365 }
3366 {
3367 PyThreadState* __tstate = wxPyBeginAllowThreads();
3368 result = (int)wxSystemOptions::GetOptionInt((wxString const &)*arg1);
3369
3370 wxPyEndAllowThreads(__tstate);
3371 if (PyErr_Occurred()) SWIG_fail;
3372 }
3373 {
3374 resultobj = SWIG_From_int((int)(result));
3375 }
3376 {
3377 if (temp1)
3378 delete arg1;
3379 }
3380 return resultobj;
3381 fail:
3382 {
3383 if (temp1)
3384 delete arg1;
3385 }
3386 return NULL;
3387 }
3388
3389
3390 static PyObject *_wrap_SystemOptions_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
3391 PyObject *resultobj;
3392 wxString *arg1 = 0 ;
3393 bool result;
3394 bool temp1 = false ;
3395 PyObject * obj0 = 0 ;
3396 char *kwnames[] = {
3397 (char *) "name", NULL
3398 };
3399
3400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SystemOptions_HasOption",kwnames,&obj0)) goto fail;
3401 {
3402 arg1 = wxString_in_helper(obj0);
3403 if (arg1 == NULL) SWIG_fail;
3404 temp1 = true;
3405 }
3406 {
3407 PyThreadState* __tstate = wxPyBeginAllowThreads();
3408 result = (bool)wxSystemOptions::HasOption((wxString const &)*arg1);
3409
3410 wxPyEndAllowThreads(__tstate);
3411 if (PyErr_Occurred()) SWIG_fail;
3412 }
3413 {
3414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3415 }
3416 {
3417 if (temp1)
3418 delete arg1;
3419 }
3420 return resultobj;
3421 fail:
3422 {
3423 if (temp1)
3424 delete arg1;
3425 }
3426 return NULL;
3427 }
3428
3429
3430 static PyObject * SystemOptions_swigregister(PyObject *, PyObject *args) {
3431 PyObject *obj;
3432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3433 SWIG_TypeClientData(SWIGTYPE_p_wxSystemOptions, obj);
3434 Py_INCREF(obj);
3435 return Py_BuildValue((char *)"");
3436 }
3437 static int _wrap_FileSelectorPromptStr_set(PyObject *) {
3438 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
3439 return 1;
3440 }
3441
3442
3443 static PyObject *_wrap_FileSelectorPromptStr_get(void) {
3444 PyObject *pyobj;
3445
3446 {
3447 #if wxUSE_UNICODE
3448 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3449 #else
3450 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
3451 #endif
3452 }
3453 return pyobj;
3454 }
3455
3456
3457 static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *) {
3458 PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
3459 return 1;
3460 }
3461
3462
3463 static PyObject *_wrap_FileSelectorDefaultWildcardStr_get(void) {
3464 PyObject *pyobj;
3465
3466 {
3467 #if wxUSE_UNICODE
3468 pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3469 #else
3470 pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
3471 #endif
3472 }
3473 return pyobj;
3474 }
3475
3476
3477 static int _wrap_DirSelectorPromptStr_set(PyObject *) {
3478 PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
3479 return 1;
3480 }
3481
3482
3483 static PyObject *_wrap_DirSelectorPromptStr_get(void) {
3484 PyObject *pyobj;
3485
3486 {
3487 #if wxUSE_UNICODE
3488 pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3489 #else
3490 pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
3491 #endif
3492 }
3493 return pyobj;
3494 }
3495
3496
3497 static PyObject *_wrap_NewId(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 long result;
3500 char *kwnames[] = {
3501 NULL
3502 };
3503
3504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewId",kwnames)) goto fail;
3505 {
3506 PyThreadState* __tstate = wxPyBeginAllowThreads();
3507 result = (long)wxNewId();
3508
3509 wxPyEndAllowThreads(__tstate);
3510 if (PyErr_Occurred()) SWIG_fail;
3511 }
3512 {
3513 resultobj = SWIG_From_long((long)(result));
3514 }
3515 return resultobj;
3516 fail:
3517 return NULL;
3518 }
3519
3520
3521 static PyObject *_wrap_RegisterId(PyObject *, PyObject *args, PyObject *kwargs) {
3522 PyObject *resultobj;
3523 long arg1 ;
3524 PyObject * obj0 = 0 ;
3525 char *kwnames[] = {
3526 (char *) "id", NULL
3527 };
3528
3529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RegisterId",kwnames,&obj0)) goto fail;
3530 {
3531 arg1 = (long)(SWIG_As_long(obj0));
3532 if (SWIG_arg_fail(1)) SWIG_fail;
3533 }
3534 {
3535 PyThreadState* __tstate = wxPyBeginAllowThreads();
3536 wxRegisterId(arg1);
3537
3538 wxPyEndAllowThreads(__tstate);
3539 if (PyErr_Occurred()) SWIG_fail;
3540 }
3541 Py_INCREF(Py_None); resultobj = Py_None;
3542 return resultobj;
3543 fail:
3544 return NULL;
3545 }
3546
3547
3548 static PyObject *_wrap_GetCurrentId(PyObject *, PyObject *args, PyObject *kwargs) {
3549 PyObject *resultobj;
3550 long result;
3551 char *kwnames[] = {
3552 NULL
3553 };
3554
3555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentId",kwnames)) goto fail;
3556 {
3557 PyThreadState* __tstate = wxPyBeginAllowThreads();
3558 result = (long)wxGetCurrentId();
3559
3560 wxPyEndAllowThreads(__tstate);
3561 if (PyErr_Occurred()) SWIG_fail;
3562 }
3563 {
3564 resultobj = SWIG_From_long((long)(result));
3565 }
3566 return resultobj;
3567 fail:
3568 return NULL;
3569 }
3570
3571
3572 static PyObject *_wrap_IsStockID(PyObject *, PyObject *args, PyObject *kwargs) {
3573 PyObject *resultobj;
3574 int arg1 ;
3575 bool result;
3576 PyObject * obj0 = 0 ;
3577 char *kwnames[] = {
3578 (char *) "id", NULL
3579 };
3580
3581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsStockID",kwnames,&obj0)) goto fail;
3582 {
3583 arg1 = (int)(SWIG_As_int(obj0));
3584 if (SWIG_arg_fail(1)) SWIG_fail;
3585 }
3586 {
3587 PyThreadState* __tstate = wxPyBeginAllowThreads();
3588 result = (bool)wxIsStockID(arg1);
3589
3590 wxPyEndAllowThreads(__tstate);
3591 if (PyErr_Occurred()) SWIG_fail;
3592 }
3593 {
3594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3595 }
3596 return resultobj;
3597 fail:
3598 return NULL;
3599 }
3600
3601
3602 static PyObject *_wrap_IsStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3603 PyObject *resultobj;
3604 int arg1 ;
3605 wxString *arg2 = 0 ;
3606 bool result;
3607 bool temp2 = false ;
3608 PyObject * obj0 = 0 ;
3609 PyObject * obj1 = 0 ;
3610 char *kwnames[] = {
3611 (char *) "id",(char *) "label", NULL
3612 };
3613
3614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IsStockLabel",kwnames,&obj0,&obj1)) goto fail;
3615 {
3616 arg1 = (int)(SWIG_As_int(obj0));
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 }
3619 {
3620 arg2 = wxString_in_helper(obj1);
3621 if (arg2 == NULL) SWIG_fail;
3622 temp2 = true;
3623 }
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 result = (bool)wxIsStockLabel(arg1,(wxString const &)*arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 {
3632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3633 }
3634 {
3635 if (temp2)
3636 delete arg2;
3637 }
3638 return resultobj;
3639 fail:
3640 {
3641 if (temp2)
3642 delete arg2;
3643 }
3644 return NULL;
3645 }
3646
3647
3648 static PyObject *_wrap_GetStockLabel(PyObject *, PyObject *args, PyObject *kwargs) {
3649 PyObject *resultobj;
3650 int arg1 ;
3651 bool arg2 = (bool) true ;
3652 wxString arg3 = (wxString) wxPyEmptyString ;
3653 wxString result;
3654 PyObject * obj0 = 0 ;
3655 PyObject * obj1 = 0 ;
3656 PyObject * obj2 = 0 ;
3657 char *kwnames[] = {
3658 (char *) "id",(char *) "withCodes",(char *) "accelerator", NULL
3659 };
3660
3661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GetStockLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
3662 {
3663 arg1 = (int)(SWIG_As_int(obj0));
3664 if (SWIG_arg_fail(1)) SWIG_fail;
3665 }
3666 if (obj1) {
3667 {
3668 arg2 = (bool)(SWIG_As_bool(obj1));
3669 if (SWIG_arg_fail(2)) SWIG_fail;
3670 }
3671 }
3672 if (obj2) {
3673 {
3674 wxString* sptr = wxString_in_helper(obj2);
3675 if (sptr == NULL) SWIG_fail;
3676 arg3 = *sptr;
3677 delete sptr;
3678 }
3679 }
3680 {
3681 PyThreadState* __tstate = wxPyBeginAllowThreads();
3682 result = wxGetStockLabel(arg1,arg2,arg3);
3683
3684 wxPyEndAllowThreads(__tstate);
3685 if (PyErr_Occurred()) SWIG_fail;
3686 }
3687 {
3688 #if wxUSE_UNICODE
3689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3690 #else
3691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3692 #endif
3693 }
3694 return resultobj;
3695 fail:
3696 return NULL;
3697 }
3698
3699
3700 static PyObject *_wrap_Bell(PyObject *, PyObject *args, PyObject *kwargs) {
3701 PyObject *resultobj;
3702 char *kwnames[] = {
3703 NULL
3704 };
3705
3706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Bell",kwnames)) goto fail;
3707 {
3708 if (!wxPyCheckForApp()) SWIG_fail;
3709 PyThreadState* __tstate = wxPyBeginAllowThreads();
3710 wxBell();
3711
3712 wxPyEndAllowThreads(__tstate);
3713 if (PyErr_Occurred()) SWIG_fail;
3714 }
3715 Py_INCREF(Py_None); resultobj = Py_None;
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_EndBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj;
3724 char *kwnames[] = {
3725 NULL
3726 };
3727
3728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EndBusyCursor",kwnames)) goto fail;
3729 {
3730 if (!wxPyCheckForApp()) SWIG_fail;
3731 PyThreadState* __tstate = wxPyBeginAllowThreads();
3732 wxEndBusyCursor();
3733
3734 wxPyEndAllowThreads(__tstate);
3735 if (PyErr_Occurred()) SWIG_fail;
3736 }
3737 Py_INCREF(Py_None); resultobj = Py_None;
3738 return resultobj;
3739 fail:
3740 return NULL;
3741 }
3742
3743
3744 static PyObject *_wrap_GetElapsedTime(PyObject *, PyObject *args, PyObject *kwargs) {
3745 PyObject *resultobj;
3746 bool arg1 = (bool) true ;
3747 long result;
3748 PyObject * obj0 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "resetTimer", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetElapsedTime",kwnames,&obj0)) goto fail;
3754 if (obj0) {
3755 {
3756 arg1 = (bool)(SWIG_As_bool(obj0));
3757 if (SWIG_arg_fail(1)) SWIG_fail;
3758 }
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 result = (long)wxGetElapsedTime(arg1);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 {
3768 resultobj = SWIG_From_long((long)(result));
3769 }
3770 return resultobj;
3771 fail:
3772 return NULL;
3773 }
3774
3775
3776 static PyObject *_wrap_GetMousePosition(PyObject *, PyObject *args, PyObject *kwargs) {
3777 PyObject *resultobj;
3778 int *arg1 = (int *) 0 ;
3779 int *arg2 = (int *) 0 ;
3780 int temp1 ;
3781 int res1 = 0 ;
3782 int temp2 ;
3783 int res2 = 0 ;
3784 char *kwnames[] = {
3785 NULL
3786 };
3787
3788 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3789 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetMousePosition",kwnames)) goto fail;
3791 {
3792 if (!wxPyCheckForApp()) SWIG_fail;
3793 PyThreadState* __tstate = wxPyBeginAllowThreads();
3794 wxGetMousePosition(arg1,arg2);
3795
3796 wxPyEndAllowThreads(__tstate);
3797 if (PyErr_Occurred()) SWIG_fail;
3798 }
3799 Py_INCREF(Py_None); resultobj = Py_None;
3800 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3801 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3802 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3803 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3804 return resultobj;
3805 fail:
3806 return NULL;
3807 }
3808
3809
3810 static PyObject *_wrap_IsBusy(PyObject *, PyObject *args, PyObject *kwargs) {
3811 PyObject *resultobj;
3812 bool result;
3813 char *kwnames[] = {
3814 NULL
3815 };
3816
3817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IsBusy",kwnames)) goto fail;
3818 {
3819 PyThreadState* __tstate = wxPyBeginAllowThreads();
3820 result = (bool)wxIsBusy();
3821
3822 wxPyEndAllowThreads(__tstate);
3823 if (PyErr_Occurred()) SWIG_fail;
3824 }
3825 {
3826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3827 }
3828 return resultobj;
3829 fail:
3830 return NULL;
3831 }
3832
3833
3834 static PyObject *_wrap_Now(PyObject *, PyObject *args, PyObject *kwargs) {
3835 PyObject *resultobj;
3836 wxString result;
3837 char *kwnames[] = {
3838 NULL
3839 };
3840
3841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Now",kwnames)) goto fail;
3842 {
3843 PyThreadState* __tstate = wxPyBeginAllowThreads();
3844 result = wxNow();
3845
3846 wxPyEndAllowThreads(__tstate);
3847 if (PyErr_Occurred()) SWIG_fail;
3848 }
3849 {
3850 #if wxUSE_UNICODE
3851 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3852 #else
3853 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3854 #endif
3855 }
3856 return resultobj;
3857 fail:
3858 return NULL;
3859 }
3860
3861
3862 static PyObject *_wrap_Shell(PyObject *, PyObject *args, PyObject *kwargs) {
3863 PyObject *resultobj;
3864 wxString const &arg1_defvalue = wxPyEmptyString ;
3865 wxString *arg1 = (wxString *) &arg1_defvalue ;
3866 bool result;
3867 bool temp1 = false ;
3868 PyObject * obj0 = 0 ;
3869 char *kwnames[] = {
3870 (char *) "command", NULL
3871 };
3872
3873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Shell",kwnames,&obj0)) goto fail;
3874 if (obj0) {
3875 {
3876 arg1 = wxString_in_helper(obj0);
3877 if (arg1 == NULL) SWIG_fail;
3878 temp1 = true;
3879 }
3880 }
3881 {
3882 PyThreadState* __tstate = wxPyBeginAllowThreads();
3883 result = (bool)wxShell((wxString const &)*arg1);
3884
3885 wxPyEndAllowThreads(__tstate);
3886 if (PyErr_Occurred()) SWIG_fail;
3887 }
3888 {
3889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3890 }
3891 {
3892 if (temp1)
3893 delete arg1;
3894 }
3895 return resultobj;
3896 fail:
3897 {
3898 if (temp1)
3899 delete arg1;
3900 }
3901 return NULL;
3902 }
3903
3904
3905 static PyObject *_wrap_StartTimer(PyObject *, PyObject *args, PyObject *kwargs) {
3906 PyObject *resultobj;
3907 char *kwnames[] = {
3908 NULL
3909 };
3910
3911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StartTimer",kwnames)) goto fail;
3912 {
3913 PyThreadState* __tstate = wxPyBeginAllowThreads();
3914 wxStartTimer();
3915
3916 wxPyEndAllowThreads(__tstate);
3917 if (PyErr_Occurred()) SWIG_fail;
3918 }
3919 Py_INCREF(Py_None); resultobj = Py_None;
3920 return resultobj;
3921 fail:
3922 return NULL;
3923 }
3924
3925
3926 static PyObject *_wrap_GetOsVersion(PyObject *, PyObject *args, PyObject *kwargs) {
3927 PyObject *resultobj;
3928 int *arg1 = (int *) 0 ;
3929 int *arg2 = (int *) 0 ;
3930 int result;
3931 int temp1 ;
3932 int res1 = 0 ;
3933 int temp2 ;
3934 int res2 = 0 ;
3935 char *kwnames[] = {
3936 NULL
3937 };
3938
3939 arg1 = &temp1; res1 = SWIG_NEWOBJ;
3940 arg2 = &temp2; res2 = SWIG_NEWOBJ;
3941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsVersion",kwnames)) goto fail;
3942 {
3943 PyThreadState* __tstate = wxPyBeginAllowThreads();
3944 result = (int)wxGetOsVersion(arg1,arg2);
3945
3946 wxPyEndAllowThreads(__tstate);
3947 if (PyErr_Occurred()) SWIG_fail;
3948 }
3949 {
3950 resultobj = SWIG_From_int((int)(result));
3951 }
3952 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
3953 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
3954 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
3955 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
3956 return resultobj;
3957 fail:
3958 return NULL;
3959 }
3960
3961
3962 static PyObject *_wrap_GetOsDescription(PyObject *, PyObject *args, PyObject *kwargs) {
3963 PyObject *resultobj;
3964 wxString result;
3965 char *kwnames[] = {
3966 NULL
3967 };
3968
3969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetOsDescription",kwnames)) goto fail;
3970 {
3971 PyThreadState* __tstate = wxPyBeginAllowThreads();
3972 result = wxGetOsDescription();
3973
3974 wxPyEndAllowThreads(__tstate);
3975 if (PyErr_Occurred()) SWIG_fail;
3976 }
3977 {
3978 #if wxUSE_UNICODE
3979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3980 #else
3981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3982 #endif
3983 }
3984 return resultobj;
3985 fail:
3986 return NULL;
3987 }
3988
3989
3990 static PyObject *_wrap_GetFreeMemory(PyObject *, PyObject *args, PyObject *kwargs) {
3991 PyObject *resultobj;
3992 long result;
3993 char *kwnames[] = {
3994 NULL
3995 };
3996
3997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFreeMemory",kwnames)) goto fail;
3998 {
3999 PyThreadState* __tstate = wxPyBeginAllowThreads();
4000 result = (long)wxGetFreeMemory();
4001
4002 wxPyEndAllowThreads(__tstate);
4003 if (PyErr_Occurred()) SWIG_fail;
4004 }
4005 {
4006 resultobj = SWIG_From_long((long)(result));
4007 }
4008 return resultobj;
4009 fail:
4010 return NULL;
4011 }
4012
4013
4014 static PyObject *_wrap_Shutdown(PyObject *, PyObject *args, PyObject *kwargs) {
4015 PyObject *resultobj;
4016 wxShutdownFlags arg1 ;
4017 bool result;
4018 PyObject * obj0 = 0 ;
4019 char *kwnames[] = {
4020 (char *) "wFlags", NULL
4021 };
4022
4023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Shutdown",kwnames,&obj0)) goto fail;
4024 {
4025 arg1 = (wxShutdownFlags)(SWIG_As_int(obj0));
4026 if (SWIG_arg_fail(1)) SWIG_fail;
4027 }
4028 {
4029 if (!wxPyCheckForApp()) SWIG_fail;
4030 PyThreadState* __tstate = wxPyBeginAllowThreads();
4031 result = (bool)wxShutdown((wxShutdownFlags )arg1);
4032
4033 wxPyEndAllowThreads(__tstate);
4034 if (PyErr_Occurred()) SWIG_fail;
4035 }
4036 {
4037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4038 }
4039 return resultobj;
4040 fail:
4041 return NULL;
4042 }
4043
4044
4045 static PyObject *_wrap_Sleep(PyObject *, PyObject *args, PyObject *kwargs) {
4046 PyObject *resultobj;
4047 int arg1 ;
4048 PyObject * obj0 = 0 ;
4049 char *kwnames[] = {
4050 (char *) "secs", NULL
4051 };
4052
4053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sleep",kwnames,&obj0)) goto fail;
4054 {
4055 arg1 = (int)(SWIG_As_int(obj0));
4056 if (SWIG_arg_fail(1)) SWIG_fail;
4057 }
4058 {
4059 PyThreadState* __tstate = wxPyBeginAllowThreads();
4060 wxSleep(arg1);
4061
4062 wxPyEndAllowThreads(__tstate);
4063 if (PyErr_Occurred()) SWIG_fail;
4064 }
4065 Py_INCREF(Py_None); resultobj = Py_None;
4066 return resultobj;
4067 fail:
4068 return NULL;
4069 }
4070
4071
4072 static PyObject *_wrap_MilliSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4073 PyObject *resultobj;
4074 unsigned long arg1 ;
4075 PyObject * obj0 = 0 ;
4076 char *kwnames[] = {
4077 (char *) "milliseconds", NULL
4078 };
4079
4080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MilliSleep",kwnames,&obj0)) goto fail;
4081 {
4082 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4083 if (SWIG_arg_fail(1)) SWIG_fail;
4084 }
4085 {
4086 PyThreadState* __tstate = wxPyBeginAllowThreads();
4087 wxMilliSleep(arg1);
4088
4089 wxPyEndAllowThreads(__tstate);
4090 if (PyErr_Occurred()) SWIG_fail;
4091 }
4092 Py_INCREF(Py_None); resultobj = Py_None;
4093 return resultobj;
4094 fail:
4095 return NULL;
4096 }
4097
4098
4099 static PyObject *_wrap_MicroSleep(PyObject *, PyObject *args, PyObject *kwargs) {
4100 PyObject *resultobj;
4101 unsigned long arg1 ;
4102 PyObject * obj0 = 0 ;
4103 char *kwnames[] = {
4104 (char *) "microseconds", NULL
4105 };
4106
4107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MicroSleep",kwnames,&obj0)) goto fail;
4108 {
4109 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
4110 if (SWIG_arg_fail(1)) SWIG_fail;
4111 }
4112 {
4113 PyThreadState* __tstate = wxPyBeginAllowThreads();
4114 wxMicroSleep(arg1);
4115
4116 wxPyEndAllowThreads(__tstate);
4117 if (PyErr_Occurred()) SWIG_fail;
4118 }
4119 Py_INCREF(Py_None); resultobj = Py_None;
4120 return resultobj;
4121 fail:
4122 return NULL;
4123 }
4124
4125
4126 static PyObject *_wrap_EnableTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
4127 PyObject *resultobj;
4128 bool arg1 ;
4129 PyObject * obj0 = 0 ;
4130 char *kwnames[] = {
4131 (char *) "enable", NULL
4132 };
4133
4134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EnableTopLevelWindows",kwnames,&obj0)) goto fail;
4135 {
4136 arg1 = (bool)(SWIG_As_bool(obj0));
4137 if (SWIG_arg_fail(1)) SWIG_fail;
4138 }
4139 {
4140 PyThreadState* __tstate = wxPyBeginAllowThreads();
4141 wxEnableTopLevelWindows(arg1);
4142
4143 wxPyEndAllowThreads(__tstate);
4144 if (PyErr_Occurred()) SWIG_fail;
4145 }
4146 Py_INCREF(Py_None); resultobj = Py_None;
4147 return resultobj;
4148 fail:
4149 return NULL;
4150 }
4151
4152
4153 static PyObject *_wrap_StripMenuCodes(PyObject *, PyObject *args, PyObject *kwargs) {
4154 PyObject *resultobj;
4155 wxString *arg1 = 0 ;
4156 wxString result;
4157 bool temp1 = false ;
4158 PyObject * obj0 = 0 ;
4159 char *kwnames[] = {
4160 (char *) "in", NULL
4161 };
4162
4163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StripMenuCodes",kwnames,&obj0)) goto fail;
4164 {
4165 arg1 = wxString_in_helper(obj0);
4166 if (arg1 == NULL) SWIG_fail;
4167 temp1 = true;
4168 }
4169 {
4170 PyThreadState* __tstate = wxPyBeginAllowThreads();
4171 result = wxStripMenuCodes((wxString const &)*arg1);
4172
4173 wxPyEndAllowThreads(__tstate);
4174 if (PyErr_Occurred()) SWIG_fail;
4175 }
4176 {
4177 #if wxUSE_UNICODE
4178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4179 #else
4180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4181 #endif
4182 }
4183 {
4184 if (temp1)
4185 delete arg1;
4186 }
4187 return resultobj;
4188 fail:
4189 {
4190 if (temp1)
4191 delete arg1;
4192 }
4193 return NULL;
4194 }
4195
4196
4197 static PyObject *_wrap_GetEmailAddress(PyObject *, PyObject *args, PyObject *kwargs) {
4198 PyObject *resultobj;
4199 wxString result;
4200 char *kwnames[] = {
4201 NULL
4202 };
4203
4204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetEmailAddress",kwnames)) goto fail;
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = wxGetEmailAddress();
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 #if wxUSE_UNICODE
4214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4215 #else
4216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4217 #endif
4218 }
4219 return resultobj;
4220 fail:
4221 return NULL;
4222 }
4223
4224
4225 static PyObject *_wrap_GetHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4226 PyObject *resultobj;
4227 wxString result;
4228 char *kwnames[] = {
4229 NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHostName",kwnames)) goto fail;
4233 {
4234 PyThreadState* __tstate = wxPyBeginAllowThreads();
4235 result = wxGetHostName();
4236
4237 wxPyEndAllowThreads(__tstate);
4238 if (PyErr_Occurred()) SWIG_fail;
4239 }
4240 {
4241 #if wxUSE_UNICODE
4242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4243 #else
4244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4245 #endif
4246 }
4247 return resultobj;
4248 fail:
4249 return NULL;
4250 }
4251
4252
4253 static PyObject *_wrap_GetFullHostName(PyObject *, PyObject *args, PyObject *kwargs) {
4254 PyObject *resultobj;
4255 wxString result;
4256 char *kwnames[] = {
4257 NULL
4258 };
4259
4260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetFullHostName",kwnames)) goto fail;
4261 {
4262 PyThreadState* __tstate = wxPyBeginAllowThreads();
4263 result = wxGetFullHostName();
4264
4265 wxPyEndAllowThreads(__tstate);
4266 if (PyErr_Occurred()) SWIG_fail;
4267 }
4268 {
4269 #if wxUSE_UNICODE
4270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4271 #else
4272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4273 #endif
4274 }
4275 return resultobj;
4276 fail:
4277 return NULL;
4278 }
4279
4280
4281 static PyObject *_wrap_GetUserId(PyObject *, PyObject *args, PyObject *kwargs) {
4282 PyObject *resultobj;
4283 wxString result;
4284 char *kwnames[] = {
4285 NULL
4286 };
4287
4288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserId",kwnames)) goto fail;
4289 {
4290 PyThreadState* __tstate = wxPyBeginAllowThreads();
4291 result = wxGetUserId();
4292
4293 wxPyEndAllowThreads(__tstate);
4294 if (PyErr_Occurred()) SWIG_fail;
4295 }
4296 {
4297 #if wxUSE_UNICODE
4298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4299 #else
4300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4301 #endif
4302 }
4303 return resultobj;
4304 fail:
4305 return NULL;
4306 }
4307
4308
4309 static PyObject *_wrap_GetUserName(PyObject *, PyObject *args, PyObject *kwargs) {
4310 PyObject *resultobj;
4311 wxString result;
4312 char *kwnames[] = {
4313 NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUserName",kwnames)) goto fail;
4317 {
4318 PyThreadState* __tstate = wxPyBeginAllowThreads();
4319 result = wxGetUserName();
4320
4321 wxPyEndAllowThreads(__tstate);
4322 if (PyErr_Occurred()) SWIG_fail;
4323 }
4324 {
4325 #if wxUSE_UNICODE
4326 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4327 #else
4328 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4329 #endif
4330 }
4331 return resultobj;
4332 fail:
4333 return NULL;
4334 }
4335
4336
4337 static PyObject *_wrap_GetHomeDir(PyObject *, PyObject *args, PyObject *kwargs) {
4338 PyObject *resultobj;
4339 wxString result;
4340 char *kwnames[] = {
4341 NULL
4342 };
4343
4344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetHomeDir",kwnames)) goto fail;
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 result = wxGetHomeDir();
4348
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 {
4353 #if wxUSE_UNICODE
4354 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4355 #else
4356 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4357 #endif
4358 }
4359 return resultobj;
4360 fail:
4361 return NULL;
4362 }
4363
4364
4365 static PyObject *_wrap_GetUserHome(PyObject *, PyObject *args, PyObject *kwargs) {
4366 PyObject *resultobj;
4367 wxString const &arg1_defvalue = wxPyEmptyString ;
4368 wxString *arg1 = (wxString *) &arg1_defvalue ;
4369 wxString result;
4370 bool temp1 = false ;
4371 PyObject * obj0 = 0 ;
4372 char *kwnames[] = {
4373 (char *) "user", NULL
4374 };
4375
4376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:GetUserHome",kwnames,&obj0)) goto fail;
4377 if (obj0) {
4378 {
4379 arg1 = wxString_in_helper(obj0);
4380 if (arg1 == NULL) SWIG_fail;
4381 temp1 = true;
4382 }
4383 }
4384 {
4385 PyThreadState* __tstate = wxPyBeginAllowThreads();
4386 result = wxGetUserHome((wxString const &)*arg1);
4387
4388 wxPyEndAllowThreads(__tstate);
4389 if (PyErr_Occurred()) SWIG_fail;
4390 }
4391 {
4392 #if wxUSE_UNICODE
4393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4394 #else
4395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4396 #endif
4397 }
4398 {
4399 if (temp1)
4400 delete arg1;
4401 }
4402 return resultobj;
4403 fail:
4404 {
4405 if (temp1)
4406 delete arg1;
4407 }
4408 return NULL;
4409 }
4410
4411
4412 static PyObject *_wrap_GetProcessId(PyObject *, PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj;
4414 unsigned long result;
4415 char *kwnames[] = {
4416 NULL
4417 };
4418
4419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetProcessId",kwnames)) goto fail;
4420 {
4421 PyThreadState* __tstate = wxPyBeginAllowThreads();
4422 result = (unsigned long)wxGetProcessId();
4423
4424 wxPyEndAllowThreads(__tstate);
4425 if (PyErr_Occurred()) SWIG_fail;
4426 }
4427 {
4428 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
4429 }
4430 return resultobj;
4431 fail:
4432 return NULL;
4433 }
4434
4435
4436 static PyObject *_wrap_Trap(PyObject *, PyObject *args, PyObject *kwargs) {
4437 PyObject *resultobj;
4438 char *kwnames[] = {
4439 NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Trap",kwnames)) goto fail;
4443 {
4444 PyThreadState* __tstate = wxPyBeginAllowThreads();
4445 wxTrap();
4446
4447 wxPyEndAllowThreads(__tstate);
4448 if (PyErr_Occurred()) SWIG_fail;
4449 }
4450 Py_INCREF(Py_None); resultobj = Py_None;
4451 return resultobj;
4452 fail:
4453 return NULL;
4454 }
4455
4456
4457 static PyObject *_wrap_FileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4458 PyObject *resultobj;
4459 wxString const &arg1_defvalue = wxPyFileSelectorPromptStr ;
4460 wxString *arg1 = (wxString *) &arg1_defvalue ;
4461 wxString const &arg2_defvalue = wxPyEmptyString ;
4462 wxString *arg2 = (wxString *) &arg2_defvalue ;
4463 wxString const &arg3_defvalue = wxPyEmptyString ;
4464 wxString *arg3 = (wxString *) &arg3_defvalue ;
4465 wxString const &arg4_defvalue = wxPyEmptyString ;
4466 wxString *arg4 = (wxString *) &arg4_defvalue ;
4467 wxString const &arg5_defvalue = wxPyFileSelectorDefaultWildcardStr ;
4468 wxString *arg5 = (wxString *) &arg5_defvalue ;
4469 int arg6 = (int) 0 ;
4470 wxWindow *arg7 = (wxWindow *) NULL ;
4471 int arg8 = (int) -1 ;
4472 int arg9 = (int) -1 ;
4473 wxString result;
4474 bool temp1 = false ;
4475 bool temp2 = false ;
4476 bool temp3 = false ;
4477 bool temp4 = false ;
4478 bool temp5 = false ;
4479 PyObject * obj0 = 0 ;
4480 PyObject * obj1 = 0 ;
4481 PyObject * obj2 = 0 ;
4482 PyObject * obj3 = 0 ;
4483 PyObject * obj4 = 0 ;
4484 PyObject * obj5 = 0 ;
4485 PyObject * obj6 = 0 ;
4486 PyObject * obj7 = 0 ;
4487 PyObject * obj8 = 0 ;
4488 char *kwnames[] = {
4489 (char *) "message",(char *) "default_path",(char *) "default_filename",(char *) "default_extension",(char *) "wildcard",(char *) "flags",(char *) "parent",(char *) "x",(char *) "y", NULL
4490 };
4491
4492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOOOOO:FileSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
4493 if (obj0) {
4494 {
4495 arg1 = wxString_in_helper(obj0);
4496 if (arg1 == NULL) SWIG_fail;
4497 temp1 = true;
4498 }
4499 }
4500 if (obj1) {
4501 {
4502 arg2 = wxString_in_helper(obj1);
4503 if (arg2 == NULL) SWIG_fail;
4504 temp2 = true;
4505 }
4506 }
4507 if (obj2) {
4508 {
4509 arg3 = wxString_in_helper(obj2);
4510 if (arg3 == NULL) SWIG_fail;
4511 temp3 = true;
4512 }
4513 }
4514 if (obj3) {
4515 {
4516 arg4 = wxString_in_helper(obj3);
4517 if (arg4 == NULL) SWIG_fail;
4518 temp4 = true;
4519 }
4520 }
4521 if (obj4) {
4522 {
4523 arg5 = wxString_in_helper(obj4);
4524 if (arg5 == NULL) SWIG_fail;
4525 temp5 = true;
4526 }
4527 }
4528 if (obj5) {
4529 {
4530 arg6 = (int)(SWIG_As_int(obj5));
4531 if (SWIG_arg_fail(6)) SWIG_fail;
4532 }
4533 }
4534 if (obj6) {
4535 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4536 if (SWIG_arg_fail(7)) SWIG_fail;
4537 }
4538 if (obj7) {
4539 {
4540 arg8 = (int)(SWIG_As_int(obj7));
4541 if (SWIG_arg_fail(8)) SWIG_fail;
4542 }
4543 }
4544 if (obj8) {
4545 {
4546 arg9 = (int)(SWIG_As_int(obj8));
4547 if (SWIG_arg_fail(9)) SWIG_fail;
4548 }
4549 }
4550 {
4551 if (!wxPyCheckForApp()) SWIG_fail;
4552 PyThreadState* __tstate = wxPyBeginAllowThreads();
4553 result = wxFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6,arg7,arg8,arg9);
4554
4555 wxPyEndAllowThreads(__tstate);
4556 if (PyErr_Occurred()) SWIG_fail;
4557 }
4558 {
4559 #if wxUSE_UNICODE
4560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4561 #else
4562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4563 #endif
4564 }
4565 {
4566 if (temp1)
4567 delete arg1;
4568 }
4569 {
4570 if (temp2)
4571 delete arg2;
4572 }
4573 {
4574 if (temp3)
4575 delete arg3;
4576 }
4577 {
4578 if (temp4)
4579 delete arg4;
4580 }
4581 {
4582 if (temp5)
4583 delete arg5;
4584 }
4585 return resultobj;
4586 fail:
4587 {
4588 if (temp1)
4589 delete arg1;
4590 }
4591 {
4592 if (temp2)
4593 delete arg2;
4594 }
4595 {
4596 if (temp3)
4597 delete arg3;
4598 }
4599 {
4600 if (temp4)
4601 delete arg4;
4602 }
4603 {
4604 if (temp5)
4605 delete arg5;
4606 }
4607 return NULL;
4608 }
4609
4610
4611 static PyObject *_wrap_LoadFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4612 PyObject *resultobj;
4613 wxString *arg1 = 0 ;
4614 wxString *arg2 = 0 ;
4615 wxString const &arg3_defvalue = wxPyEmptyString ;
4616 wxString *arg3 = (wxString *) &arg3_defvalue ;
4617 wxWindow *arg4 = (wxWindow *) NULL ;
4618 wxString result;
4619 bool temp1 = false ;
4620 bool temp2 = false ;
4621 bool temp3 = false ;
4622 PyObject * obj0 = 0 ;
4623 PyObject * obj1 = 0 ;
4624 PyObject * obj2 = 0 ;
4625 PyObject * obj3 = 0 ;
4626 char *kwnames[] = {
4627 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4628 };
4629
4630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:LoadFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4631 {
4632 arg1 = wxString_in_helper(obj0);
4633 if (arg1 == NULL) SWIG_fail;
4634 temp1 = true;
4635 }
4636 {
4637 arg2 = wxString_in_helper(obj1);
4638 if (arg2 == NULL) SWIG_fail;
4639 temp2 = true;
4640 }
4641 if (obj2) {
4642 {
4643 arg3 = wxString_in_helper(obj2);
4644 if (arg3 == NULL) SWIG_fail;
4645 temp3 = true;
4646 }
4647 }
4648 if (obj3) {
4649 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4650 if (SWIG_arg_fail(4)) SWIG_fail;
4651 }
4652 {
4653 if (!wxPyCheckForApp()) SWIG_fail;
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 result = wxLoadFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4656
4657 wxPyEndAllowThreads(__tstate);
4658 if (PyErr_Occurred()) SWIG_fail;
4659 }
4660 {
4661 #if wxUSE_UNICODE
4662 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4663 #else
4664 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4665 #endif
4666 }
4667 {
4668 if (temp1)
4669 delete arg1;
4670 }
4671 {
4672 if (temp2)
4673 delete arg2;
4674 }
4675 {
4676 if (temp3)
4677 delete arg3;
4678 }
4679 return resultobj;
4680 fail:
4681 {
4682 if (temp1)
4683 delete arg1;
4684 }
4685 {
4686 if (temp2)
4687 delete arg2;
4688 }
4689 {
4690 if (temp3)
4691 delete arg3;
4692 }
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_SaveFileSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj;
4699 wxString *arg1 = 0 ;
4700 wxString *arg2 = 0 ;
4701 wxString const &arg3_defvalue = wxPyEmptyString ;
4702 wxString *arg3 = (wxString *) &arg3_defvalue ;
4703 wxWindow *arg4 = (wxWindow *) NULL ;
4704 wxString result;
4705 bool temp1 = false ;
4706 bool temp2 = false ;
4707 bool temp3 = false ;
4708 PyObject * obj0 = 0 ;
4709 PyObject * obj1 = 0 ;
4710 PyObject * obj2 = 0 ;
4711 PyObject * obj3 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "what",(char *) "extension",(char *) "default_name",(char *) "parent", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:SaveFileSelector",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4717 {
4718 arg1 = wxString_in_helper(obj0);
4719 if (arg1 == NULL) SWIG_fail;
4720 temp1 = true;
4721 }
4722 {
4723 arg2 = wxString_in_helper(obj1);
4724 if (arg2 == NULL) SWIG_fail;
4725 temp2 = true;
4726 }
4727 if (obj2) {
4728 {
4729 arg3 = wxString_in_helper(obj2);
4730 if (arg3 == NULL) SWIG_fail;
4731 temp3 = true;
4732 }
4733 }
4734 if (obj3) {
4735 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4736 if (SWIG_arg_fail(4)) SWIG_fail;
4737 }
4738 {
4739 if (!wxPyCheckForApp()) SWIG_fail;
4740 PyThreadState* __tstate = wxPyBeginAllowThreads();
4741 result = wxSaveFileSelector((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
4742
4743 wxPyEndAllowThreads(__tstate);
4744 if (PyErr_Occurred()) SWIG_fail;
4745 }
4746 {
4747 #if wxUSE_UNICODE
4748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4749 #else
4750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4751 #endif
4752 }
4753 {
4754 if (temp1)
4755 delete arg1;
4756 }
4757 {
4758 if (temp2)
4759 delete arg2;
4760 }
4761 {
4762 if (temp3)
4763 delete arg3;
4764 }
4765 return resultobj;
4766 fail:
4767 {
4768 if (temp1)
4769 delete arg1;
4770 }
4771 {
4772 if (temp2)
4773 delete arg2;
4774 }
4775 {
4776 if (temp3)
4777 delete arg3;
4778 }
4779 return NULL;
4780 }
4781
4782
4783 static PyObject *_wrap_DirSelector(PyObject *, PyObject *args, PyObject *kwargs) {
4784 PyObject *resultobj;
4785 wxString const &arg1_defvalue = wxPyDirSelectorPromptStr ;
4786 wxString *arg1 = (wxString *) &arg1_defvalue ;
4787 wxString const &arg2_defvalue = wxPyEmptyString ;
4788 wxString *arg2 = (wxString *) &arg2_defvalue ;
4789 long arg3 = (long) wxDD_DEFAULT_STYLE ;
4790 wxPoint const &arg4_defvalue = wxDefaultPosition ;
4791 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
4792 wxWindow *arg5 = (wxWindow *) NULL ;
4793 wxString result;
4794 bool temp1 = false ;
4795 bool temp2 = false ;
4796 wxPoint temp4 ;
4797 PyObject * obj0 = 0 ;
4798 PyObject * obj1 = 0 ;
4799 PyObject * obj2 = 0 ;
4800 PyObject * obj3 = 0 ;
4801 PyObject * obj4 = 0 ;
4802 char *kwnames[] = {
4803 (char *) "message",(char *) "defaultPath",(char *) "style",(char *) "pos",(char *) "parent", NULL
4804 };
4805
4806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:DirSelector",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
4807 if (obj0) {
4808 {
4809 arg1 = wxString_in_helper(obj0);
4810 if (arg1 == NULL) SWIG_fail;
4811 temp1 = true;
4812 }
4813 }
4814 if (obj1) {
4815 {
4816 arg2 = wxString_in_helper(obj1);
4817 if (arg2 == NULL) SWIG_fail;
4818 temp2 = true;
4819 }
4820 }
4821 if (obj2) {
4822 {
4823 arg3 = (long)(SWIG_As_long(obj2));
4824 if (SWIG_arg_fail(3)) SWIG_fail;
4825 }
4826 }
4827 if (obj3) {
4828 {
4829 arg4 = &temp4;
4830 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
4831 }
4832 }
4833 if (obj4) {
4834 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4835 if (SWIG_arg_fail(5)) SWIG_fail;
4836 }
4837 {
4838 if (!wxPyCheckForApp()) SWIG_fail;
4839 PyThreadState* __tstate = wxPyBeginAllowThreads();
4840 result = wxDirSelector((wxString const &)*arg1,(wxString const &)*arg2,arg3,(wxPoint const &)*arg4,arg5);
4841
4842 wxPyEndAllowThreads(__tstate);
4843 if (PyErr_Occurred()) SWIG_fail;
4844 }
4845 {
4846 #if wxUSE_UNICODE
4847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4848 #else
4849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4850 #endif
4851 }
4852 {
4853 if (temp1)
4854 delete arg1;
4855 }
4856 {
4857 if (temp2)
4858 delete arg2;
4859 }
4860 return resultobj;
4861 fail:
4862 {
4863 if (temp1)
4864 delete arg1;
4865 }
4866 {
4867 if (temp2)
4868 delete arg2;
4869 }
4870 return NULL;
4871 }
4872
4873
4874 static PyObject *_wrap_GetTextFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4875 PyObject *resultobj;
4876 wxString *arg1 = 0 ;
4877 wxString const &arg2_defvalue = wxPyEmptyString ;
4878 wxString *arg2 = (wxString *) &arg2_defvalue ;
4879 wxString const &arg3_defvalue = wxPyEmptyString ;
4880 wxString *arg3 = (wxString *) &arg3_defvalue ;
4881 wxWindow *arg4 = (wxWindow *) NULL ;
4882 int arg5 = (int) -1 ;
4883 int arg6 = (int) -1 ;
4884 bool arg7 = (bool) true ;
4885 wxString result;
4886 bool temp1 = false ;
4887 bool temp2 = false ;
4888 bool temp3 = false ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 PyObject * obj2 = 0 ;
4892 PyObject * obj3 = 0 ;
4893 PyObject * obj4 = 0 ;
4894 PyObject * obj5 = 0 ;
4895 PyObject * obj6 = 0 ;
4896 char *kwnames[] = {
4897 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre", NULL
4898 };
4899
4900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:GetTextFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
4901 {
4902 arg1 = wxString_in_helper(obj0);
4903 if (arg1 == NULL) SWIG_fail;
4904 temp1 = true;
4905 }
4906 if (obj1) {
4907 {
4908 arg2 = wxString_in_helper(obj1);
4909 if (arg2 == NULL) SWIG_fail;
4910 temp2 = true;
4911 }
4912 }
4913 if (obj2) {
4914 {
4915 arg3 = wxString_in_helper(obj2);
4916 if (arg3 == NULL) SWIG_fail;
4917 temp3 = true;
4918 }
4919 }
4920 if (obj3) {
4921 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
4922 if (SWIG_arg_fail(4)) SWIG_fail;
4923 }
4924 if (obj4) {
4925 {
4926 arg5 = (int)(SWIG_As_int(obj4));
4927 if (SWIG_arg_fail(5)) SWIG_fail;
4928 }
4929 }
4930 if (obj5) {
4931 {
4932 arg6 = (int)(SWIG_As_int(obj5));
4933 if (SWIG_arg_fail(6)) SWIG_fail;
4934 }
4935 }
4936 if (obj6) {
4937 {
4938 arg7 = (bool)(SWIG_As_bool(obj6));
4939 if (SWIG_arg_fail(7)) SWIG_fail;
4940 }
4941 }
4942 {
4943 if (!wxPyCheckForApp()) SWIG_fail;
4944 PyThreadState* __tstate = wxPyBeginAllowThreads();
4945 result = wxGetTextFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7);
4946
4947 wxPyEndAllowThreads(__tstate);
4948 if (PyErr_Occurred()) SWIG_fail;
4949 }
4950 {
4951 #if wxUSE_UNICODE
4952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4953 #else
4954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4955 #endif
4956 }
4957 {
4958 if (temp1)
4959 delete arg1;
4960 }
4961 {
4962 if (temp2)
4963 delete arg2;
4964 }
4965 {
4966 if (temp3)
4967 delete arg3;
4968 }
4969 return resultobj;
4970 fail:
4971 {
4972 if (temp1)
4973 delete arg1;
4974 }
4975 {
4976 if (temp2)
4977 delete arg2;
4978 }
4979 {
4980 if (temp3)
4981 delete arg3;
4982 }
4983 return NULL;
4984 }
4985
4986
4987 static PyObject *_wrap_GetPasswordFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
4988 PyObject *resultobj;
4989 wxString *arg1 = 0 ;
4990 wxString const &arg2_defvalue = wxPyEmptyString ;
4991 wxString *arg2 = (wxString *) &arg2_defvalue ;
4992 wxString const &arg3_defvalue = wxPyEmptyString ;
4993 wxString *arg3 = (wxString *) &arg3_defvalue ;
4994 wxWindow *arg4 = (wxWindow *) NULL ;
4995 wxString result;
4996 bool temp1 = false ;
4997 bool temp2 = false ;
4998 bool temp3 = false ;
4999 PyObject * obj0 = 0 ;
5000 PyObject * obj1 = 0 ;
5001 PyObject * obj2 = 0 ;
5002 PyObject * obj3 = 0 ;
5003 char *kwnames[] = {
5004 (char *) "message",(char *) "caption",(char *) "default_value",(char *) "parent", NULL
5005 };
5006
5007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:GetPasswordFromUser",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
5008 {
5009 arg1 = wxString_in_helper(obj0);
5010 if (arg1 == NULL) SWIG_fail;
5011 temp1 = true;
5012 }
5013 if (obj1) {
5014 {
5015 arg2 = wxString_in_helper(obj1);
5016 if (arg2 == NULL) SWIG_fail;
5017 temp2 = true;
5018 }
5019 }
5020 if (obj2) {
5021 {
5022 arg3 = wxString_in_helper(obj2);
5023 if (arg3 == NULL) SWIG_fail;
5024 temp3 = true;
5025 }
5026 }
5027 if (obj3) {
5028 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5029 if (SWIG_arg_fail(4)) SWIG_fail;
5030 }
5031 {
5032 if (!wxPyCheckForApp()) SWIG_fail;
5033 PyThreadState* __tstate = wxPyBeginAllowThreads();
5034 result = wxGetPasswordFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4);
5035
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 #if wxUSE_UNICODE
5041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5042 #else
5043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5044 #endif
5045 }
5046 {
5047 if (temp1)
5048 delete arg1;
5049 }
5050 {
5051 if (temp2)
5052 delete arg2;
5053 }
5054 {
5055 if (temp3)
5056 delete arg3;
5057 }
5058 return resultobj;
5059 fail:
5060 {
5061 if (temp1)
5062 delete arg1;
5063 }
5064 {
5065 if (temp2)
5066 delete arg2;
5067 }
5068 {
5069 if (temp3)
5070 delete arg3;
5071 }
5072 return NULL;
5073 }
5074
5075
5076 static PyObject *_wrap_GetSingleChoice(PyObject *, PyObject *args, PyObject *kwargs) {
5077 PyObject *resultobj;
5078 wxString *arg1 = 0 ;
5079 wxString *arg2 = 0 ;
5080 int arg3 ;
5081 wxString *arg4 = (wxString *) 0 ;
5082 wxWindow *arg5 = (wxWindow *) NULL ;
5083 int arg6 = (int) -1 ;
5084 int arg7 = (int) -1 ;
5085 bool arg8 = (bool) true ;
5086 int arg9 = (int) 150 ;
5087 int arg10 = (int) 200 ;
5088 wxString result;
5089 bool temp1 = false ;
5090 bool temp2 = false ;
5091 PyObject * obj0 = 0 ;
5092 PyObject * obj1 = 0 ;
5093 PyObject * obj2 = 0 ;
5094 PyObject * obj3 = 0 ;
5095 PyObject * obj4 = 0 ;
5096 PyObject * obj5 = 0 ;
5097 PyObject * obj6 = 0 ;
5098 PyObject * obj7 = 0 ;
5099 PyObject * obj8 = 0 ;
5100 char *kwnames[] = {
5101 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5102 };
5103
5104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoice",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5105 {
5106 arg1 = wxString_in_helper(obj0);
5107 if (arg1 == NULL) SWIG_fail;
5108 temp1 = true;
5109 }
5110 {
5111 arg2 = wxString_in_helper(obj1);
5112 if (arg2 == NULL) SWIG_fail;
5113 temp2 = true;
5114 }
5115 {
5116 arg3 = PyList_Size(obj2);
5117 arg4 = wxString_LIST_helper(obj2);
5118 if (arg4 == NULL) SWIG_fail;
5119 }
5120 if (obj3) {
5121 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5122 if (SWIG_arg_fail(5)) SWIG_fail;
5123 }
5124 if (obj4) {
5125 {
5126 arg6 = (int)(SWIG_As_int(obj4));
5127 if (SWIG_arg_fail(6)) SWIG_fail;
5128 }
5129 }
5130 if (obj5) {
5131 {
5132 arg7 = (int)(SWIG_As_int(obj5));
5133 if (SWIG_arg_fail(7)) SWIG_fail;
5134 }
5135 }
5136 if (obj6) {
5137 {
5138 arg8 = (bool)(SWIG_As_bool(obj6));
5139 if (SWIG_arg_fail(8)) SWIG_fail;
5140 }
5141 }
5142 if (obj7) {
5143 {
5144 arg9 = (int)(SWIG_As_int(obj7));
5145 if (SWIG_arg_fail(9)) SWIG_fail;
5146 }
5147 }
5148 if (obj8) {
5149 {
5150 arg10 = (int)(SWIG_As_int(obj8));
5151 if (SWIG_arg_fail(10)) SWIG_fail;
5152 }
5153 }
5154 {
5155 if (!wxPyCheckForApp()) SWIG_fail;
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 result = wxGetSingleChoice((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 {
5163 #if wxUSE_UNICODE
5164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
5165 #else
5166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
5167 #endif
5168 }
5169 {
5170 if (temp1)
5171 delete arg1;
5172 }
5173 {
5174 if (temp2)
5175 delete arg2;
5176 }
5177 {
5178 if (arg4) delete [] arg4;
5179 }
5180 return resultobj;
5181 fail:
5182 {
5183 if (temp1)
5184 delete arg1;
5185 }
5186 {
5187 if (temp2)
5188 delete arg2;
5189 }
5190 {
5191 if (arg4) delete [] arg4;
5192 }
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_GetSingleChoiceIndex(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj;
5199 wxString *arg1 = 0 ;
5200 wxString *arg2 = 0 ;
5201 int arg3 ;
5202 wxString *arg4 = (wxString *) 0 ;
5203 wxWindow *arg5 = (wxWindow *) NULL ;
5204 int arg6 = (int) -1 ;
5205 int arg7 = (int) -1 ;
5206 bool arg8 = (bool) true ;
5207 int arg9 = (int) 150 ;
5208 int arg10 = (int) 200 ;
5209 int result;
5210 bool temp1 = false ;
5211 bool temp2 = false ;
5212 PyObject * obj0 = 0 ;
5213 PyObject * obj1 = 0 ;
5214 PyObject * obj2 = 0 ;
5215 PyObject * obj3 = 0 ;
5216 PyObject * obj4 = 0 ;
5217 PyObject * obj5 = 0 ;
5218 PyObject * obj6 = 0 ;
5219 PyObject * obj7 = 0 ;
5220 PyObject * obj8 = 0 ;
5221 char *kwnames[] = {
5222 (char *) "message",(char *) "caption",(char *) "choices",(char *) "parent",(char *) "x",(char *) "y",(char *) "centre",(char *) "width",(char *) "height", NULL
5223 };
5224
5225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOOOO:GetSingleChoiceIndex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) goto fail;
5226 {
5227 arg1 = wxString_in_helper(obj0);
5228 if (arg1 == NULL) SWIG_fail;
5229 temp1 = true;
5230 }
5231 {
5232 arg2 = wxString_in_helper(obj1);
5233 if (arg2 == NULL) SWIG_fail;
5234 temp2 = true;
5235 }
5236 {
5237 arg3 = PyList_Size(obj2);
5238 arg4 = wxString_LIST_helper(obj2);
5239 if (arg4 == NULL) SWIG_fail;
5240 }
5241 if (obj3) {
5242 SWIG_Python_ConvertPtr(obj3, (void **)&arg5, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5243 if (SWIG_arg_fail(5)) SWIG_fail;
5244 }
5245 if (obj4) {
5246 {
5247 arg6 = (int)(SWIG_As_int(obj4));
5248 if (SWIG_arg_fail(6)) SWIG_fail;
5249 }
5250 }
5251 if (obj5) {
5252 {
5253 arg7 = (int)(SWIG_As_int(obj5));
5254 if (SWIG_arg_fail(7)) SWIG_fail;
5255 }
5256 }
5257 if (obj6) {
5258 {
5259 arg8 = (bool)(SWIG_As_bool(obj6));
5260 if (SWIG_arg_fail(8)) SWIG_fail;
5261 }
5262 }
5263 if (obj7) {
5264 {
5265 arg9 = (int)(SWIG_As_int(obj7));
5266 if (SWIG_arg_fail(9)) SWIG_fail;
5267 }
5268 }
5269 if (obj8) {
5270 {
5271 arg10 = (int)(SWIG_As_int(obj8));
5272 if (SWIG_arg_fail(10)) SWIG_fail;
5273 }
5274 }
5275 {
5276 if (!wxPyCheckForApp()) SWIG_fail;
5277 PyThreadState* __tstate = wxPyBeginAllowThreads();
5278 result = (int)wxGetSingleChoiceIndex((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
5279
5280 wxPyEndAllowThreads(__tstate);
5281 if (PyErr_Occurred()) SWIG_fail;
5282 }
5283 {
5284 resultobj = SWIG_From_int((int)(result));
5285 }
5286 {
5287 if (temp1)
5288 delete arg1;
5289 }
5290 {
5291 if (temp2)
5292 delete arg2;
5293 }
5294 {
5295 if (arg4) delete [] arg4;
5296 }
5297 return resultobj;
5298 fail:
5299 {
5300 if (temp1)
5301 delete arg1;
5302 }
5303 {
5304 if (temp2)
5305 delete arg2;
5306 }
5307 {
5308 if (arg4) delete [] arg4;
5309 }
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_MessageBox(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxString *arg1 = 0 ;
5317 wxString const &arg2_defvalue = wxPyEmptyString ;
5318 wxString *arg2 = (wxString *) &arg2_defvalue ;
5319 int arg3 = (int) wxOK|wxCENTRE ;
5320 wxWindow *arg4 = (wxWindow *) NULL ;
5321 int arg5 = (int) -1 ;
5322 int arg6 = (int) -1 ;
5323 int result;
5324 bool temp1 = false ;
5325 bool temp2 = false ;
5326 PyObject * obj0 = 0 ;
5327 PyObject * obj1 = 0 ;
5328 PyObject * obj2 = 0 ;
5329 PyObject * obj3 = 0 ;
5330 PyObject * obj4 = 0 ;
5331 PyObject * obj5 = 0 ;
5332 char *kwnames[] = {
5333 (char *) "message",(char *) "caption",(char *) "style",(char *) "parent",(char *) "x",(char *) "y", NULL
5334 };
5335
5336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:MessageBox",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
5337 {
5338 arg1 = wxString_in_helper(obj0);
5339 if (arg1 == NULL) SWIG_fail;
5340 temp1 = true;
5341 }
5342 if (obj1) {
5343 {
5344 arg2 = wxString_in_helper(obj1);
5345 if (arg2 == NULL) SWIG_fail;
5346 temp2 = true;
5347 }
5348 }
5349 if (obj2) {
5350 {
5351 arg3 = (int)(SWIG_As_int(obj2));
5352 if (SWIG_arg_fail(3)) SWIG_fail;
5353 }
5354 }
5355 if (obj3) {
5356 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5357 if (SWIG_arg_fail(4)) SWIG_fail;
5358 }
5359 if (obj4) {
5360 {
5361 arg5 = (int)(SWIG_As_int(obj4));
5362 if (SWIG_arg_fail(5)) SWIG_fail;
5363 }
5364 }
5365 if (obj5) {
5366 {
5367 arg6 = (int)(SWIG_As_int(obj5));
5368 if (SWIG_arg_fail(6)) SWIG_fail;
5369 }
5370 }
5371 {
5372 if (!wxPyCheckForApp()) SWIG_fail;
5373 PyThreadState* __tstate = wxPyBeginAllowThreads();
5374 result = (int)wxMessageBox((wxString const &)*arg1,(wxString const &)*arg2,arg3,arg4,arg5,arg6);
5375
5376 wxPyEndAllowThreads(__tstate);
5377 if (PyErr_Occurred()) SWIG_fail;
5378 }
5379 {
5380 resultobj = SWIG_From_int((int)(result));
5381 }
5382 {
5383 if (temp1)
5384 delete arg1;
5385 }
5386 {
5387 if (temp2)
5388 delete arg2;
5389 }
5390 return resultobj;
5391 fail:
5392 {
5393 if (temp1)
5394 delete arg1;
5395 }
5396 {
5397 if (temp2)
5398 delete arg2;
5399 }
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_GetNumberFromUser(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxString *arg1 = 0 ;
5407 wxString *arg2 = 0 ;
5408 wxString *arg3 = 0 ;
5409 long arg4 ;
5410 long arg5 = (long) 0 ;
5411 long arg6 = (long) 100 ;
5412 wxWindow *arg7 = (wxWindow *) NULL ;
5413 wxPoint const &arg8_defvalue = wxDefaultPosition ;
5414 wxPoint *arg8 = (wxPoint *) &arg8_defvalue ;
5415 long result;
5416 bool temp1 = false ;
5417 bool temp2 = false ;
5418 bool temp3 = false ;
5419 wxPoint temp8 ;
5420 PyObject * obj0 = 0 ;
5421 PyObject * obj1 = 0 ;
5422 PyObject * obj2 = 0 ;
5423 PyObject * obj3 = 0 ;
5424 PyObject * obj4 = 0 ;
5425 PyObject * obj5 = 0 ;
5426 PyObject * obj6 = 0 ;
5427 PyObject * obj7 = 0 ;
5428 char *kwnames[] = {
5429 (char *) "message",(char *) "prompt",(char *) "caption",(char *) "value",(char *) "min",(char *) "max",(char *) "parent",(char *) "pos", NULL
5430 };
5431
5432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OOOO:GetNumberFromUser",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
5433 {
5434 arg1 = wxString_in_helper(obj0);
5435 if (arg1 == NULL) SWIG_fail;
5436 temp1 = true;
5437 }
5438 {
5439 arg2 = wxString_in_helper(obj1);
5440 if (arg2 == NULL) SWIG_fail;
5441 temp2 = true;
5442 }
5443 {
5444 arg3 = wxString_in_helper(obj2);
5445 if (arg3 == NULL) SWIG_fail;
5446 temp3 = true;
5447 }
5448 {
5449 arg4 = (long)(SWIG_As_long(obj3));
5450 if (SWIG_arg_fail(4)) SWIG_fail;
5451 }
5452 if (obj4) {
5453 {
5454 arg5 = (long)(SWIG_As_long(obj4));
5455 if (SWIG_arg_fail(5)) SWIG_fail;
5456 }
5457 }
5458 if (obj5) {
5459 {
5460 arg6 = (long)(SWIG_As_long(obj5));
5461 if (SWIG_arg_fail(6)) SWIG_fail;
5462 }
5463 }
5464 if (obj6) {
5465 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5466 if (SWIG_arg_fail(7)) SWIG_fail;
5467 }
5468 if (obj7) {
5469 {
5470 arg8 = &temp8;
5471 if ( ! wxPoint_helper(obj7, &arg8)) SWIG_fail;
5472 }
5473 }
5474 {
5475 if (!wxPyCheckForApp()) SWIG_fail;
5476 PyThreadState* __tstate = wxPyBeginAllowThreads();
5477 result = (long)wxGetNumberFromUser((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,arg4,arg5,arg6,arg7,(wxPoint const &)*arg8);
5478
5479 wxPyEndAllowThreads(__tstate);
5480 if (PyErr_Occurred()) SWIG_fail;
5481 }
5482 {
5483 resultobj = SWIG_From_long((long)(result));
5484 }
5485 {
5486 if (temp1)
5487 delete arg1;
5488 }
5489 {
5490 if (temp2)
5491 delete arg2;
5492 }
5493 {
5494 if (temp3)
5495 delete arg3;
5496 }
5497 return resultobj;
5498 fail:
5499 {
5500 if (temp1)
5501 delete arg1;
5502 }
5503 {
5504 if (temp2)
5505 delete arg2;
5506 }
5507 {
5508 if (temp3)
5509 delete arg3;
5510 }
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_ColourDisplay(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj;
5517 bool result;
5518 char *kwnames[] = {
5519 NULL
5520 };
5521
5522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ColourDisplay",kwnames)) goto fail;
5523 {
5524 if (!wxPyCheckForApp()) SWIG_fail;
5525 PyThreadState* __tstate = wxPyBeginAllowThreads();
5526 result = (bool)wxColourDisplay();
5527
5528 wxPyEndAllowThreads(__tstate);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 static PyObject *_wrap_DisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj;
5542 int result;
5543 char *kwnames[] = {
5544 NULL
5545 };
5546
5547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplayDepth",kwnames)) goto fail;
5548 {
5549 if (!wxPyCheckForApp()) SWIG_fail;
5550 PyThreadState* __tstate = wxPyBeginAllowThreads();
5551 result = (int)wxDisplayDepth();
5552
5553 wxPyEndAllowThreads(__tstate);
5554 if (PyErr_Occurred()) SWIG_fail;
5555 }
5556 {
5557 resultobj = SWIG_From_int((int)(result));
5558 }
5559 return resultobj;
5560 fail:
5561 return NULL;
5562 }
5563
5564
5565 static PyObject *_wrap_GetDisplayDepth(PyObject *, PyObject *args, PyObject *kwargs) {
5566 PyObject *resultobj;
5567 int result;
5568 char *kwnames[] = {
5569 NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplayDepth",kwnames)) goto fail;
5573 {
5574 if (!wxPyCheckForApp()) SWIG_fail;
5575 PyThreadState* __tstate = wxPyBeginAllowThreads();
5576 result = (int)wxGetDisplayDepth();
5577
5578 wxPyEndAllowThreads(__tstate);
5579 if (PyErr_Occurred()) SWIG_fail;
5580 }
5581 {
5582 resultobj = SWIG_From_int((int)(result));
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 static PyObject *_wrap_DisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5591 PyObject *resultobj;
5592 int *arg1 = (int *) 0 ;
5593 int *arg2 = (int *) 0 ;
5594 int temp1 ;
5595 int res1 = 0 ;
5596 int temp2 ;
5597 int res2 = 0 ;
5598 char *kwnames[] = {
5599 NULL
5600 };
5601
5602 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5603 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySize",kwnames)) goto fail;
5605 {
5606 if (!wxPyCheckForApp()) SWIG_fail;
5607 PyThreadState* __tstate = wxPyBeginAllowThreads();
5608 wxDisplaySize(arg1,arg2);
5609
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 Py_INCREF(Py_None); resultobj = Py_None;
5614 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5615 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5616 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5617 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_GetDisplaySize(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxSize result;
5627 char *kwnames[] = {
5628 NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySize",kwnames)) goto fail;
5632 {
5633 if (!wxPyCheckForApp()) SWIG_fail;
5634 PyThreadState* __tstate = wxPyBeginAllowThreads();
5635 result = wxGetDisplaySize();
5636
5637 wxPyEndAllowThreads(__tstate);
5638 if (PyErr_Occurred()) SWIG_fail;
5639 }
5640 {
5641 wxSize * resultptr;
5642 resultptr = new wxSize((wxSize &)(result));
5643 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5644 }
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 static PyObject *_wrap_DisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj;
5653 int *arg1 = (int *) 0 ;
5654 int *arg2 = (int *) 0 ;
5655 int temp1 ;
5656 int res1 = 0 ;
5657 int temp2 ;
5658 int res2 = 0 ;
5659 char *kwnames[] = {
5660 NULL
5661 };
5662
5663 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5664 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DisplaySizeMM",kwnames)) goto fail;
5666 {
5667 if (!wxPyCheckForApp()) SWIG_fail;
5668 PyThreadState* __tstate = wxPyBeginAllowThreads();
5669 wxDisplaySizeMM(arg1,arg2);
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 Py_INCREF(Py_None); resultobj = Py_None;
5675 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5676 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5677 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5678 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 static PyObject *_wrap_GetDisplaySizeMM(PyObject *, PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj;
5687 wxSize result;
5688 char *kwnames[] = {
5689 NULL
5690 };
5691
5692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDisplaySizeMM",kwnames)) goto fail;
5693 {
5694 if (!wxPyCheckForApp()) SWIG_fail;
5695 PyThreadState* __tstate = wxPyBeginAllowThreads();
5696 result = wxGetDisplaySizeMM();
5697
5698 wxPyEndAllowThreads(__tstate);
5699 if (PyErr_Occurred()) SWIG_fail;
5700 }
5701 {
5702 wxSize * resultptr;
5703 resultptr = new wxSize((wxSize &)(result));
5704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5705 }
5706 return resultobj;
5707 fail:
5708 return NULL;
5709 }
5710
5711
5712 static PyObject *_wrap_ClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5713 PyObject *resultobj;
5714 int *arg1 = (int *) 0 ;
5715 int *arg2 = (int *) 0 ;
5716 int *arg3 = (int *) 0 ;
5717 int *arg4 = (int *) 0 ;
5718 int temp1 ;
5719 int res1 = 0 ;
5720 int temp2 ;
5721 int res2 = 0 ;
5722 int temp3 ;
5723 int res3 = 0 ;
5724 int temp4 ;
5725 int res4 = 0 ;
5726 char *kwnames[] = {
5727 NULL
5728 };
5729
5730 arg1 = &temp1; res1 = SWIG_NEWOBJ;
5731 arg2 = &temp2; res2 = SWIG_NEWOBJ;
5732 arg3 = &temp3; res3 = SWIG_NEWOBJ;
5733 arg4 = &temp4; res4 = SWIG_NEWOBJ;
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ClientDisplayRect",kwnames)) goto fail;
5735 {
5736 if (!wxPyCheckForApp()) SWIG_fail;
5737 PyThreadState* __tstate = wxPyBeginAllowThreads();
5738 wxClientDisplayRect(arg1,arg2,arg3,arg4);
5739
5740 wxPyEndAllowThreads(__tstate);
5741 if (PyErr_Occurred()) SWIG_fail;
5742 }
5743 Py_INCREF(Py_None); resultobj = Py_None;
5744 resultobj = t_output_helper(resultobj, ((res1 == SWIG_NEWOBJ) ?
5745 SWIG_From_int((*arg1)) : SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, 0)));
5746 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
5747 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
5748 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
5749 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
5750 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
5751 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
5752 return resultobj;
5753 fail:
5754 return NULL;
5755 }
5756
5757
5758 static PyObject *_wrap_GetClientDisplayRect(PyObject *, PyObject *args, PyObject *kwargs) {
5759 PyObject *resultobj;
5760 wxRect result;
5761 char *kwnames[] = {
5762 NULL
5763 };
5764
5765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetClientDisplayRect",kwnames)) goto fail;
5766 {
5767 if (!wxPyCheckForApp()) SWIG_fail;
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 result = wxGetClientDisplayRect();
5770
5771 wxPyEndAllowThreads(__tstate);
5772 if (PyErr_Occurred()) SWIG_fail;
5773 }
5774 {
5775 wxRect * resultptr;
5776 resultptr = new wxRect((wxRect &)(result));
5777 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5778 }
5779 return resultobj;
5780 fail:
5781 return NULL;
5782 }
5783
5784
5785 static PyObject *_wrap_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5786 PyObject *resultobj;
5787 wxCursor *arg1 = 0 ;
5788 PyObject * obj0 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "cursor", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursor",kwnames,&obj0)) goto fail;
5794 {
5795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5796 if (SWIG_arg_fail(1)) SWIG_fail;
5797 if (arg1 == NULL) {
5798 SWIG_null_ref("wxCursor");
5799 }
5800 if (SWIG_arg_fail(1)) SWIG_fail;
5801 }
5802 {
5803 if (!wxPyCheckForApp()) SWIG_fail;
5804 PyThreadState* __tstate = wxPyBeginAllowThreads();
5805 wxSetCursor(*arg1);
5806
5807 wxPyEndAllowThreads(__tstate);
5808 if (PyErr_Occurred()) SWIG_fail;
5809 }
5810 Py_INCREF(Py_None); resultobj = Py_None;
5811 return resultobj;
5812 fail:
5813 return NULL;
5814 }
5815
5816
5817 static PyObject *_wrap_BeginBusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
5818 PyObject *resultobj;
5819 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
5820 PyObject * obj0 = 0 ;
5821 char *kwnames[] = {
5822 (char *) "cursor", NULL
5823 };
5824
5825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:BeginBusyCursor",kwnames,&obj0)) goto fail;
5826 if (obj0) {
5827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
5828 if (SWIG_arg_fail(1)) SWIG_fail;
5829 }
5830 {
5831 if (!wxPyCheckForApp()) SWIG_fail;
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 wxBeginBusyCursor(arg1);
5834
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 Py_INCREF(Py_None); resultobj = Py_None;
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_GetActiveWindow(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj;
5847 wxWindow *result;
5848 char *kwnames[] = {
5849 NULL
5850 };
5851
5852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetActiveWindow",kwnames)) goto fail;
5853 {
5854 if (!wxPyCheckForApp()) SWIG_fail;
5855 PyThreadState* __tstate = wxPyBeginAllowThreads();
5856 result = (wxWindow *)wxGetActiveWindow();
5857
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 {
5862 resultobj = wxPyMake_wxObject(result, 0);
5863 }
5864 return resultobj;
5865 fail:
5866 return NULL;
5867 }
5868
5869
5870 static PyObject *_wrap_GenericFindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5871 PyObject *resultobj;
5872 wxPoint *arg1 = 0 ;
5873 wxWindow *result;
5874 wxPoint temp1 ;
5875 PyObject * obj0 = 0 ;
5876 char *kwnames[] = {
5877 (char *) "pt", NULL
5878 };
5879
5880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GenericFindWindowAtPoint",kwnames,&obj0)) goto fail;
5881 {
5882 arg1 = &temp1;
5883 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5884 }
5885 {
5886 if (!wxPyCheckForApp()) SWIG_fail;
5887 PyThreadState* __tstate = wxPyBeginAllowThreads();
5888 result = (wxWindow *)wxGenericFindWindowAtPoint((wxPoint const &)*arg1);
5889
5890 wxPyEndAllowThreads(__tstate);
5891 if (PyErr_Occurred()) SWIG_fail;
5892 }
5893 {
5894 resultobj = wxPyMake_wxObject(result, 0);
5895 }
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_FindWindowAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj;
5904 wxPoint *arg1 = 0 ;
5905 wxWindow *result;
5906 wxPoint temp1 ;
5907 PyObject * obj0 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "pt", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FindWindowAtPoint",kwnames,&obj0)) goto fail;
5913 {
5914 arg1 = &temp1;
5915 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5916 }
5917 {
5918 if (!wxPyCheckForApp()) SWIG_fail;
5919 PyThreadState* __tstate = wxPyBeginAllowThreads();
5920 result = (wxWindow *)wxFindWindowAtPoint((wxPoint const &)*arg1);
5921
5922 wxPyEndAllowThreads(__tstate);
5923 if (PyErr_Occurred()) SWIG_fail;
5924 }
5925 {
5926 resultobj = wxPyMake_wxObject(result, 0);
5927 }
5928 return resultobj;
5929 fail:
5930 return NULL;
5931 }
5932
5933
5934 static PyObject *_wrap_GetTopLevelParent(PyObject *, PyObject *args, PyObject *kwargs) {
5935 PyObject *resultobj;
5936 wxWindow *arg1 = (wxWindow *) 0 ;
5937 wxWindow *result;
5938 PyObject * obj0 = 0 ;
5939 char *kwnames[] = {
5940 (char *) "win", NULL
5941 };
5942
5943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetTopLevelParent",kwnames,&obj0)) goto fail;
5944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
5945 if (SWIG_arg_fail(1)) SWIG_fail;
5946 {
5947 if (!wxPyCheckForApp()) SWIG_fail;
5948 PyThreadState* __tstate = wxPyBeginAllowThreads();
5949 result = (wxWindow *)wxGetTopLevelParent(arg1);
5950
5951 wxPyEndAllowThreads(__tstate);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = wxPyMake_wxObject(result, 0);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 static PyObject *_wrap_GetKeyState(PyObject *, PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj;
5965 wxKeyCode arg1 ;
5966 bool result;
5967 PyObject * obj0 = 0 ;
5968 char *kwnames[] = {
5969 (char *) "key", NULL
5970 };
5971
5972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetKeyState",kwnames,&obj0)) goto fail;
5973 {
5974 arg1 = (wxKeyCode)(SWIG_As_int(obj0));
5975 if (SWIG_arg_fail(1)) SWIG_fail;
5976 }
5977 {
5978 if (!wxPyCheckForApp()) SWIG_fail;
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 result = (bool)wxGetKeyState((wxKeyCode )arg1);
5981
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 {
5986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5987 }
5988 return resultobj;
5989 fail:
5990 return NULL;
5991 }
5992
5993
5994 static PyObject *_wrap_WakeUpMainThread(PyObject *, PyObject *args, PyObject *kwargs) {
5995 PyObject *resultobj;
5996 char *kwnames[] = {
5997 NULL
5998 };
5999
6000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpMainThread",kwnames)) goto fail;
6001 {
6002 if (!wxPyCheckForApp()) SWIG_fail;
6003 PyThreadState* __tstate = wxPyBeginAllowThreads();
6004 wxWakeUpMainThread();
6005
6006 wxPyEndAllowThreads(__tstate);
6007 if (PyErr_Occurred()) SWIG_fail;
6008 }
6009 Py_INCREF(Py_None); resultobj = Py_None;
6010 return resultobj;
6011 fail:
6012 return NULL;
6013 }
6014
6015
6016 static PyObject *_wrap_MutexGuiEnter(PyObject *, PyObject *args, PyObject *kwargs) {
6017 PyObject *resultobj;
6018 char *kwnames[] = {
6019 NULL
6020 };
6021
6022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiEnter",kwnames)) goto fail;
6023 {
6024 if (!wxPyCheckForApp()) SWIG_fail;
6025 PyThreadState* __tstate = wxPyBeginAllowThreads();
6026 wxMutexGuiEnter();
6027
6028 wxPyEndAllowThreads(__tstate);
6029 if (PyErr_Occurred()) SWIG_fail;
6030 }
6031 Py_INCREF(Py_None); resultobj = Py_None;
6032 return resultobj;
6033 fail:
6034 return NULL;
6035 }
6036
6037
6038 static PyObject *_wrap_MutexGuiLeave(PyObject *, PyObject *args, PyObject *kwargs) {
6039 PyObject *resultobj;
6040 char *kwnames[] = {
6041 NULL
6042 };
6043
6044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MutexGuiLeave",kwnames)) goto fail;
6045 {
6046 if (!wxPyCheckForApp()) SWIG_fail;
6047 PyThreadState* __tstate = wxPyBeginAllowThreads();
6048 wxMutexGuiLeave();
6049
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 Py_INCREF(Py_None); resultobj = Py_None;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 static PyObject *_wrap_new_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6061 PyObject *resultobj;
6062 wxMutexGuiLocker *result;
6063 char *kwnames[] = {
6064 NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MutexGuiLocker",kwnames)) goto fail;
6068 {
6069 if (!wxPyCheckForApp()) SWIG_fail;
6070 PyThreadState* __tstate = wxPyBeginAllowThreads();
6071 result = (wxMutexGuiLocker *)new wxMutexGuiLocker();
6072
6073 wxPyEndAllowThreads(__tstate);
6074 if (PyErr_Occurred()) SWIG_fail;
6075 }
6076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMutexGuiLocker, 1);
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 static PyObject *_wrap_delete_MutexGuiLocker(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 wxMutexGuiLocker *arg1 = (wxMutexGuiLocker *) 0 ;
6086 PyObject * obj0 = 0 ;
6087 char *kwnames[] = {
6088 (char *) "self", NULL
6089 };
6090
6091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MutexGuiLocker",kwnames,&obj0)) goto fail;
6092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMutexGuiLocker, SWIG_POINTER_EXCEPTION | 0);
6093 if (SWIG_arg_fail(1)) SWIG_fail;
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 delete arg1;
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 Py_INCREF(Py_None); resultobj = Py_None;
6102 return resultobj;
6103 fail:
6104 return NULL;
6105 }
6106
6107
6108 static PyObject * MutexGuiLocker_swigregister(PyObject *, PyObject *args) {
6109 PyObject *obj;
6110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6111 SWIG_TypeClientData(SWIGTYPE_p_wxMutexGuiLocker, obj);
6112 Py_INCREF(obj);
6113 return Py_BuildValue((char *)"");
6114 }
6115 static PyObject *_wrap_Thread_IsMain(PyObject *, PyObject *args, PyObject *kwargs) {
6116 PyObject *resultobj;
6117 bool result;
6118 char *kwnames[] = {
6119 NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Thread_IsMain",kwnames)) goto fail;
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (bool)wxThread_IsMain();
6126
6127 wxPyEndAllowThreads(__tstate);
6128 if (PyErr_Occurred()) SWIG_fail;
6129 }
6130 {
6131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6132 }
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_new_ToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj;
6141 wxString *arg1 = 0 ;
6142 wxToolTip *result;
6143 bool temp1 = false ;
6144 PyObject * obj0 = 0 ;
6145 char *kwnames[] = {
6146 (char *) "tip", NULL
6147 };
6148
6149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ToolTip",kwnames,&obj0)) goto fail;
6150 {
6151 arg1 = wxString_in_helper(obj0);
6152 if (arg1 == NULL) SWIG_fail;
6153 temp1 = true;
6154 }
6155 {
6156 if (!wxPyCheckForApp()) SWIG_fail;
6157 PyThreadState* __tstate = wxPyBeginAllowThreads();
6158 result = (wxToolTip *)new wxToolTip((wxString const &)*arg1);
6159
6160 wxPyEndAllowThreads(__tstate);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 {
6164 resultobj = wxPyMake_wxObject(result, 1);
6165 }
6166 {
6167 if (temp1)
6168 delete arg1;
6169 }
6170 return resultobj;
6171 fail:
6172 {
6173 if (temp1)
6174 delete arg1;
6175 }
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_ToolTip_SetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxToolTip *arg1 = (wxToolTip *) 0 ;
6183 wxString *arg2 = 0 ;
6184 bool temp2 = false ;
6185 PyObject * obj0 = 0 ;
6186 PyObject * obj1 = 0 ;
6187 char *kwnames[] = {
6188 (char *) "self",(char *) "tip", NULL
6189 };
6190
6191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolTip_SetTip",kwnames,&obj0,&obj1)) goto fail;
6192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6193 if (SWIG_arg_fail(1)) SWIG_fail;
6194 {
6195 arg2 = wxString_in_helper(obj1);
6196 if (arg2 == NULL) SWIG_fail;
6197 temp2 = true;
6198 }
6199 {
6200 PyThreadState* __tstate = wxPyBeginAllowThreads();
6201 (arg1)->SetTip((wxString const &)*arg2);
6202
6203 wxPyEndAllowThreads(__tstate);
6204 if (PyErr_Occurred()) SWIG_fail;
6205 }
6206 Py_INCREF(Py_None); resultobj = Py_None;
6207 {
6208 if (temp2)
6209 delete arg2;
6210 }
6211 return resultobj;
6212 fail:
6213 {
6214 if (temp2)
6215 delete arg2;
6216 }
6217 return NULL;
6218 }
6219
6220
6221 static PyObject *_wrap_ToolTip_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj;
6223 wxToolTip *arg1 = (wxToolTip *) 0 ;
6224 wxString result;
6225 PyObject * obj0 = 0 ;
6226 char *kwnames[] = {
6227 (char *) "self", NULL
6228 };
6229
6230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetTip",kwnames,&obj0)) goto fail;
6231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6232 if (SWIG_arg_fail(1)) SWIG_fail;
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 result = (arg1)->GetTip();
6236
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 {
6241 #if wxUSE_UNICODE
6242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
6243 #else
6244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
6245 #endif
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_ToolTip_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj;
6255 wxToolTip *arg1 = (wxToolTip *) 0 ;
6256 wxWindow *result;
6257 PyObject * obj0 = 0 ;
6258 char *kwnames[] = {
6259 (char *) "self", NULL
6260 };
6261
6262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_GetWindow",kwnames,&obj0)) goto fail;
6263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
6264 if (SWIG_arg_fail(1)) SWIG_fail;
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 result = (wxWindow *)(arg1)->GetWindow();
6268
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 {
6273 resultobj = wxPyMake_wxObject(result, 0);
6274 }
6275 return resultobj;
6276 fail:
6277 return NULL;
6278 }
6279
6280
6281 static PyObject *_wrap_ToolTip_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
6282 PyObject *resultobj;
6283 bool arg1 ;
6284 PyObject * obj0 = 0 ;
6285 char *kwnames[] = {
6286 (char *) "flag", NULL
6287 };
6288
6289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_Enable",kwnames,&obj0)) goto fail;
6290 {
6291 arg1 = (bool)(SWIG_As_bool(obj0));
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 }
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 wxToolTip::Enable(arg1);
6297
6298 wxPyEndAllowThreads(__tstate);
6299 if (PyErr_Occurred()) SWIG_fail;
6300 }
6301 Py_INCREF(Py_None); resultobj = Py_None;
6302 return resultobj;
6303 fail:
6304 return NULL;
6305 }
6306
6307
6308 static PyObject *_wrap_ToolTip_SetDelay(PyObject *, PyObject *args, PyObject *kwargs) {
6309 PyObject *resultobj;
6310 long arg1 ;
6311 PyObject * obj0 = 0 ;
6312 char *kwnames[] = {
6313 (char *) "milliseconds", NULL
6314 };
6315
6316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ToolTip_SetDelay",kwnames,&obj0)) goto fail;
6317 {
6318 arg1 = (long)(SWIG_As_long(obj0));
6319 if (SWIG_arg_fail(1)) SWIG_fail;
6320 }
6321 {
6322 PyThreadState* __tstate = wxPyBeginAllowThreads();
6323 wxToolTip::SetDelay(arg1);
6324
6325 wxPyEndAllowThreads(__tstate);
6326 if (PyErr_Occurred()) SWIG_fail;
6327 }
6328 Py_INCREF(Py_None); resultobj = Py_None;
6329 return resultobj;
6330 fail:
6331 return NULL;
6332 }
6333
6334
6335 static PyObject * ToolTip_swigregister(PyObject *, PyObject *args) {
6336 PyObject *obj;
6337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6338 SWIG_TypeClientData(SWIGTYPE_p_wxToolTip, obj);
6339 Py_INCREF(obj);
6340 return Py_BuildValue((char *)"");
6341 }
6342 static PyObject *_wrap_new_Caret(PyObject *, PyObject *args, PyObject *kwargs) {
6343 PyObject *resultobj;
6344 wxWindow *arg1 = (wxWindow *) 0 ;
6345 wxSize *arg2 = 0 ;
6346 wxCaret *result;
6347 wxSize temp2 ;
6348 PyObject * obj0 = 0 ;
6349 PyObject * obj1 = 0 ;
6350 char *kwnames[] = {
6351 (char *) "window",(char *) "size", NULL
6352 };
6353
6354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Caret",kwnames,&obj0,&obj1)) goto fail;
6355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 {
6358 arg2 = &temp2;
6359 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6360 }
6361 {
6362 if (!wxPyCheckForApp()) SWIG_fail;
6363 PyThreadState* __tstate = wxPyBeginAllowThreads();
6364 result = (wxCaret *)new wxCaret(arg1,(wxSize const &)*arg2);
6365
6366 wxPyEndAllowThreads(__tstate);
6367 if (PyErr_Occurred()) SWIG_fail;
6368 }
6369 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 1);
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Caret_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxCaret *arg1 = (wxCaret *) 0 ;
6379 PyObject * obj0 = 0 ;
6380 char *kwnames[] = {
6381 (char *) "self", NULL
6382 };
6383
6384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Destroy",kwnames,&obj0)) goto fail;
6385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6386 if (SWIG_arg_fail(1)) SWIG_fail;
6387 {
6388 PyThreadState* __tstate = wxPyBeginAllowThreads();
6389 wxCaret_Destroy(arg1);
6390
6391 wxPyEndAllowThreads(__tstate);
6392 if (PyErr_Occurred()) SWIG_fail;
6393 }
6394 Py_INCREF(Py_None); resultobj = Py_None;
6395 return resultobj;
6396 fail:
6397 return NULL;
6398 }
6399
6400
6401 static PyObject *_wrap_Caret_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
6402 PyObject *resultobj;
6403 wxCaret *arg1 = (wxCaret *) 0 ;
6404 bool result;
6405 PyObject * obj0 = 0 ;
6406 char *kwnames[] = {
6407 (char *) "self", NULL
6408 };
6409
6410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsOk",kwnames,&obj0)) goto fail;
6411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6412 if (SWIG_arg_fail(1)) SWIG_fail;
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (bool)(arg1)->IsOk();
6416
6417 wxPyEndAllowThreads(__tstate);
6418 if (PyErr_Occurred()) SWIG_fail;
6419 }
6420 {
6421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6422 }
6423 return resultobj;
6424 fail:
6425 return NULL;
6426 }
6427
6428
6429 static PyObject *_wrap_Caret_IsVisible(PyObject *, PyObject *args, PyObject *kwargs) {
6430 PyObject *resultobj;
6431 wxCaret *arg1 = (wxCaret *) 0 ;
6432 bool result;
6433 PyObject * obj0 = 0 ;
6434 char *kwnames[] = {
6435 (char *) "self", NULL
6436 };
6437
6438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_IsVisible",kwnames,&obj0)) goto fail;
6439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6440 if (SWIG_arg_fail(1)) SWIG_fail;
6441 {
6442 PyThreadState* __tstate = wxPyBeginAllowThreads();
6443 result = (bool)(arg1)->IsVisible();
6444
6445 wxPyEndAllowThreads(__tstate);
6446 if (PyErr_Occurred()) SWIG_fail;
6447 }
6448 {
6449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6450 }
6451 return resultobj;
6452 fail:
6453 return NULL;
6454 }
6455
6456
6457 static PyObject *_wrap_Caret_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
6458 PyObject *resultobj;
6459 wxCaret *arg1 = (wxCaret *) 0 ;
6460 wxPoint result;
6461 PyObject * obj0 = 0 ;
6462 char *kwnames[] = {
6463 (char *) "self", NULL
6464 };
6465
6466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPosition",kwnames,&obj0)) goto fail;
6467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6468 if (SWIG_arg_fail(1)) SWIG_fail;
6469 {
6470 PyThreadState* __tstate = wxPyBeginAllowThreads();
6471 result = (arg1)->GetPosition();
6472
6473 wxPyEndAllowThreads(__tstate);
6474 if (PyErr_Occurred()) SWIG_fail;
6475 }
6476 {
6477 wxPoint * resultptr;
6478 resultptr = new wxPoint((wxPoint &)(result));
6479 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
6480 }
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 static PyObject *_wrap_Caret_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj;
6489 wxCaret *arg1 = (wxCaret *) 0 ;
6490 int *arg2 = (int *) 0 ;
6491 int *arg3 = (int *) 0 ;
6492 int temp2 ;
6493 int res2 = 0 ;
6494 int temp3 ;
6495 int res3 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "self", NULL
6499 };
6500
6501 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6502 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetPositionTuple",kwnames,&obj0)) goto fail;
6504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6505 if (SWIG_arg_fail(1)) SWIG_fail;
6506 {
6507 PyThreadState* __tstate = wxPyBeginAllowThreads();
6508 (arg1)->GetPosition(arg2,arg3);
6509
6510 wxPyEndAllowThreads(__tstate);
6511 if (PyErr_Occurred()) SWIG_fail;
6512 }
6513 Py_INCREF(Py_None); resultobj = Py_None;
6514 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6515 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6516 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6517 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6518 return resultobj;
6519 fail:
6520 return NULL;
6521 }
6522
6523
6524 static PyObject *_wrap_Caret_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6525 PyObject *resultobj;
6526 wxCaret *arg1 = (wxCaret *) 0 ;
6527 wxSize result;
6528 PyObject * obj0 = 0 ;
6529 char *kwnames[] = {
6530 (char *) "self", NULL
6531 };
6532
6533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSize",kwnames,&obj0)) goto fail;
6534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6535 if (SWIG_arg_fail(1)) SWIG_fail;
6536 {
6537 PyThreadState* __tstate = wxPyBeginAllowThreads();
6538 result = (arg1)->GetSize();
6539
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 {
6544 wxSize * resultptr;
6545 resultptr = new wxSize((wxSize &)(result));
6546 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
6547 }
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 static PyObject *_wrap_Caret_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj;
6556 wxCaret *arg1 = (wxCaret *) 0 ;
6557 int *arg2 = (int *) 0 ;
6558 int *arg3 = (int *) 0 ;
6559 int temp2 ;
6560 int res2 = 0 ;
6561 int temp3 ;
6562 int res3 = 0 ;
6563 PyObject * obj0 = 0 ;
6564 char *kwnames[] = {
6565 (char *) "self", NULL
6566 };
6567
6568 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6569 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetSizeTuple",kwnames,&obj0)) goto fail;
6571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6572 if (SWIG_arg_fail(1)) SWIG_fail;
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 (arg1)->GetSize(arg2,arg3);
6576
6577 wxPyEndAllowThreads(__tstate);
6578 if (PyErr_Occurred()) SWIG_fail;
6579 }
6580 Py_INCREF(Py_None); resultobj = Py_None;
6581 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6582 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6583 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6584 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6585 return resultobj;
6586 fail:
6587 return NULL;
6588 }
6589
6590
6591 static PyObject *_wrap_Caret_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
6592 PyObject *resultobj;
6593 wxCaret *arg1 = (wxCaret *) 0 ;
6594 wxWindow *result;
6595 PyObject * obj0 = 0 ;
6596 char *kwnames[] = {
6597 (char *) "self", NULL
6598 };
6599
6600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_GetWindow",kwnames,&obj0)) goto fail;
6601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6602 if (SWIG_arg_fail(1)) SWIG_fail;
6603 {
6604 PyThreadState* __tstate = wxPyBeginAllowThreads();
6605 result = (wxWindow *)(arg1)->GetWindow();
6606
6607 wxPyEndAllowThreads(__tstate);
6608 if (PyErr_Occurred()) SWIG_fail;
6609 }
6610 {
6611 resultobj = wxPyMake_wxObject(result, 0);
6612 }
6613 return resultobj;
6614 fail:
6615 return NULL;
6616 }
6617
6618
6619 static PyObject *_wrap_Caret_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
6620 PyObject *resultobj;
6621 wxCaret *arg1 = (wxCaret *) 0 ;
6622 int arg2 ;
6623 int arg3 ;
6624 PyObject * obj0 = 0 ;
6625 PyObject * obj1 = 0 ;
6626 PyObject * obj2 = 0 ;
6627 char *kwnames[] = {
6628 (char *) "self",(char *) "x",(char *) "y", NULL
6629 };
6630
6631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_MoveXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6633 if (SWIG_arg_fail(1)) SWIG_fail;
6634 {
6635 arg2 = (int)(SWIG_As_int(obj1));
6636 if (SWIG_arg_fail(2)) SWIG_fail;
6637 }
6638 {
6639 arg3 = (int)(SWIG_As_int(obj2));
6640 if (SWIG_arg_fail(3)) SWIG_fail;
6641 }
6642 {
6643 PyThreadState* __tstate = wxPyBeginAllowThreads();
6644 (arg1)->Move(arg2,arg3);
6645
6646 wxPyEndAllowThreads(__tstate);
6647 if (PyErr_Occurred()) SWIG_fail;
6648 }
6649 Py_INCREF(Py_None); resultobj = Py_None;
6650 return resultobj;
6651 fail:
6652 return NULL;
6653 }
6654
6655
6656 static PyObject *_wrap_Caret_Move(PyObject *, PyObject *args, PyObject *kwargs) {
6657 PyObject *resultobj;
6658 wxCaret *arg1 = (wxCaret *) 0 ;
6659 wxPoint *arg2 = 0 ;
6660 wxPoint temp2 ;
6661 PyObject * obj0 = 0 ;
6662 PyObject * obj1 = 0 ;
6663 char *kwnames[] = {
6664 (char *) "self",(char *) "pt", NULL
6665 };
6666
6667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_Move",kwnames,&obj0,&obj1)) goto fail;
6668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6669 if (SWIG_arg_fail(1)) SWIG_fail;
6670 {
6671 arg2 = &temp2;
6672 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6673 }
6674 {
6675 PyThreadState* __tstate = wxPyBeginAllowThreads();
6676 (arg1)->Move((wxPoint const &)*arg2);
6677
6678 wxPyEndAllowThreads(__tstate);
6679 if (PyErr_Occurred()) SWIG_fail;
6680 }
6681 Py_INCREF(Py_None); resultobj = Py_None;
6682 return resultobj;
6683 fail:
6684 return NULL;
6685 }
6686
6687
6688 static PyObject *_wrap_Caret_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
6689 PyObject *resultobj;
6690 wxCaret *arg1 = (wxCaret *) 0 ;
6691 int arg2 ;
6692 int arg3 ;
6693 PyObject * obj0 = 0 ;
6694 PyObject * obj1 = 0 ;
6695 PyObject * obj2 = 0 ;
6696 char *kwnames[] = {
6697 (char *) "self",(char *) "width",(char *) "height", NULL
6698 };
6699
6700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Caret_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
6701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6702 if (SWIG_arg_fail(1)) SWIG_fail;
6703 {
6704 arg2 = (int)(SWIG_As_int(obj1));
6705 if (SWIG_arg_fail(2)) SWIG_fail;
6706 }
6707 {
6708 arg3 = (int)(SWIG_As_int(obj2));
6709 if (SWIG_arg_fail(3)) SWIG_fail;
6710 }
6711 {
6712 PyThreadState* __tstate = wxPyBeginAllowThreads();
6713 (arg1)->SetSize(arg2,arg3);
6714
6715 wxPyEndAllowThreads(__tstate);
6716 if (PyErr_Occurred()) SWIG_fail;
6717 }
6718 Py_INCREF(Py_None); resultobj = Py_None;
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 static PyObject *_wrap_Caret_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj;
6727 wxCaret *arg1 = (wxCaret *) 0 ;
6728 wxSize *arg2 = 0 ;
6729 wxSize temp2 ;
6730 PyObject * obj0 = 0 ;
6731 PyObject * obj1 = 0 ;
6732 char *kwnames[] = {
6733 (char *) "self",(char *) "size", NULL
6734 };
6735
6736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Caret_SetSize",kwnames,&obj0,&obj1)) goto fail;
6737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6738 if (SWIG_arg_fail(1)) SWIG_fail;
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 PyThreadState* __tstate = wxPyBeginAllowThreads();
6745 (arg1)->SetSize((wxSize const &)*arg2);
6746
6747 wxPyEndAllowThreads(__tstate);
6748 if (PyErr_Occurred()) SWIG_fail;
6749 }
6750 Py_INCREF(Py_None); resultobj = Py_None;
6751 return resultobj;
6752 fail:
6753 return NULL;
6754 }
6755
6756
6757 static PyObject *_wrap_Caret_Show(PyObject *, PyObject *args, PyObject *kwargs) {
6758 PyObject *resultobj;
6759 wxCaret *arg1 = (wxCaret *) 0 ;
6760 int arg2 = (int) true ;
6761 PyObject * obj0 = 0 ;
6762 PyObject * obj1 = 0 ;
6763 char *kwnames[] = {
6764 (char *) "self",(char *) "show", NULL
6765 };
6766
6767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Caret_Show",kwnames,&obj0,&obj1)) goto fail;
6768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6769 if (SWIG_arg_fail(1)) SWIG_fail;
6770 if (obj1) {
6771 {
6772 arg2 = (int)(SWIG_As_int(obj1));
6773 if (SWIG_arg_fail(2)) SWIG_fail;
6774 }
6775 }
6776 {
6777 PyThreadState* __tstate = wxPyBeginAllowThreads();
6778 (arg1)->Show(arg2);
6779
6780 wxPyEndAllowThreads(__tstate);
6781 if (PyErr_Occurred()) SWIG_fail;
6782 }
6783 Py_INCREF(Py_None); resultobj = Py_None;
6784 return resultobj;
6785 fail:
6786 return NULL;
6787 }
6788
6789
6790 static PyObject *_wrap_Caret_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
6791 PyObject *resultobj;
6792 wxCaret *arg1 = (wxCaret *) 0 ;
6793 PyObject * obj0 = 0 ;
6794 char *kwnames[] = {
6795 (char *) "self", NULL
6796 };
6797
6798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_Hide",kwnames,&obj0)) goto fail;
6799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
6800 if (SWIG_arg_fail(1)) SWIG_fail;
6801 {
6802 PyThreadState* __tstate = wxPyBeginAllowThreads();
6803 (arg1)->Hide();
6804
6805 wxPyEndAllowThreads(__tstate);
6806 if (PyErr_Occurred()) SWIG_fail;
6807 }
6808 Py_INCREF(Py_None); resultobj = Py_None;
6809 return resultobj;
6810 fail:
6811 return NULL;
6812 }
6813
6814
6815 static PyObject *_wrap_Caret_GetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6816 PyObject *resultobj;
6817 int result;
6818 char *kwnames[] = {
6819 NULL
6820 };
6821
6822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Caret_GetBlinkTime",kwnames)) goto fail;
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (int)wxCaret::GetBlinkTime();
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = SWIG_From_int((int)(result));
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Caret_SetBlinkTime(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 int arg1 ;
6842 PyObject * obj0 = 0 ;
6843 char *kwnames[] = {
6844 (char *) "milliseconds", NULL
6845 };
6846
6847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Caret_SetBlinkTime",kwnames,&obj0)) goto fail;
6848 {
6849 arg1 = (int)(SWIG_As_int(obj0));
6850 if (SWIG_arg_fail(1)) SWIG_fail;
6851 }
6852 {
6853 PyThreadState* __tstate = wxPyBeginAllowThreads();
6854 wxCaret::SetBlinkTime(arg1);
6855
6856 wxPyEndAllowThreads(__tstate);
6857 if (PyErr_Occurred()) SWIG_fail;
6858 }
6859 Py_INCREF(Py_None); resultobj = Py_None;
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 static PyObject * Caret_swigregister(PyObject *, PyObject *args) {
6867 PyObject *obj;
6868 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6869 SWIG_TypeClientData(SWIGTYPE_p_wxCaret, obj);
6870 Py_INCREF(obj);
6871 return Py_BuildValue((char *)"");
6872 }
6873 static PyObject *_wrap_new_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6874 PyObject *resultobj;
6875 wxCursor *arg1 = (wxCursor *) wxHOURGLASS_CURSOR ;
6876 wxBusyCursor *result;
6877 PyObject * obj0 = 0 ;
6878 char *kwnames[] = {
6879 (char *) "cursor", NULL
6880 };
6881
6882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BusyCursor",kwnames,&obj0)) goto fail;
6883 if (obj0) {
6884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
6885 if (SWIG_arg_fail(1)) SWIG_fail;
6886 }
6887 {
6888 if (!wxPyCheckForApp()) SWIG_fail;
6889 PyThreadState* __tstate = wxPyBeginAllowThreads();
6890 result = (wxBusyCursor *)new wxBusyCursor(arg1);
6891
6892 wxPyEndAllowThreads(__tstate);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyCursor, 1);
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 static PyObject *_wrap_delete_BusyCursor(PyObject *, PyObject *args, PyObject *kwargs) {
6903 PyObject *resultobj;
6904 wxBusyCursor *arg1 = (wxBusyCursor *) 0 ;
6905 PyObject * obj0 = 0 ;
6906 char *kwnames[] = {
6907 (char *) "self", NULL
6908 };
6909
6910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyCursor",kwnames,&obj0)) goto fail;
6911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyCursor, SWIG_POINTER_EXCEPTION | 0);
6912 if (SWIG_arg_fail(1)) SWIG_fail;
6913 {
6914 PyThreadState* __tstate = wxPyBeginAllowThreads();
6915 delete arg1;
6916
6917 wxPyEndAllowThreads(__tstate);
6918 if (PyErr_Occurred()) SWIG_fail;
6919 }
6920 Py_INCREF(Py_None); resultobj = Py_None;
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject * BusyCursor_swigregister(PyObject *, PyObject *args) {
6928 PyObject *obj;
6929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6930 SWIG_TypeClientData(SWIGTYPE_p_wxBusyCursor, obj);
6931 Py_INCREF(obj);
6932 return Py_BuildValue((char *)"");
6933 }
6934 static PyObject *_wrap_new_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6935 PyObject *resultobj;
6936 wxWindow *arg1 = (wxWindow *) NULL ;
6937 wxWindowDisabler *result;
6938 PyObject * obj0 = 0 ;
6939 char *kwnames[] = {
6940 (char *) "winToSkip", NULL
6941 };
6942
6943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDisabler",kwnames,&obj0)) goto fail;
6944 if (obj0) {
6945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
6946 if (SWIG_arg_fail(1)) SWIG_fail;
6947 }
6948 {
6949 if (!wxPyCheckForApp()) SWIG_fail;
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 result = (wxWindowDisabler *)new wxWindowDisabler(arg1);
6952
6953 wxPyEndAllowThreads(__tstate);
6954 if (PyErr_Occurred()) SWIG_fail;
6955 }
6956 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDisabler, 1);
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_delete_WindowDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj;
6965 wxWindowDisabler *arg1 = (wxWindowDisabler *) 0 ;
6966 PyObject * obj0 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_WindowDisabler",kwnames,&obj0)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDisabler, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 delete arg1;
6977
6978 wxPyEndAllowThreads(__tstate);
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 Py_INCREF(Py_None); resultobj = Py_None;
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 static PyObject * WindowDisabler_swigregister(PyObject *, PyObject *args) {
6989 PyObject *obj;
6990 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6991 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDisabler, obj);
6992 Py_INCREF(obj);
6993 return Py_BuildValue((char *)"");
6994 }
6995 static PyObject *_wrap_new_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
6996 PyObject *resultobj;
6997 wxString *arg1 = 0 ;
6998 wxBusyInfo *result;
6999 bool temp1 = false ;
7000 PyObject * obj0 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "message", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_BusyInfo",kwnames,&obj0)) goto fail;
7006 {
7007 arg1 = wxString_in_helper(obj0);
7008 if (arg1 == NULL) SWIG_fail;
7009 temp1 = true;
7010 }
7011 {
7012 if (!wxPyCheckForApp()) SWIG_fail;
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 result = (wxBusyInfo *)new wxBusyInfo((wxString const &)*arg1);
7015
7016 wxPyEndAllowThreads(__tstate);
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBusyInfo, 1);
7020 {
7021 if (temp1)
7022 delete arg1;
7023 }
7024 return resultobj;
7025 fail:
7026 {
7027 if (temp1)
7028 delete arg1;
7029 }
7030 return NULL;
7031 }
7032
7033
7034 static PyObject *_wrap_delete_BusyInfo(PyObject *, PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj;
7036 wxBusyInfo *arg1 = (wxBusyInfo *) 0 ;
7037 PyObject * obj0 = 0 ;
7038 char *kwnames[] = {
7039 (char *) "self", NULL
7040 };
7041
7042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_BusyInfo",kwnames,&obj0)) goto fail;
7043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBusyInfo, SWIG_POINTER_EXCEPTION | 0);
7044 if (SWIG_arg_fail(1)) SWIG_fail;
7045 {
7046 PyThreadState* __tstate = wxPyBeginAllowThreads();
7047 delete arg1;
7048
7049 wxPyEndAllowThreads(__tstate);
7050 if (PyErr_Occurred()) SWIG_fail;
7051 }
7052 Py_INCREF(Py_None); resultobj = Py_None;
7053 return resultobj;
7054 fail:
7055 return NULL;
7056 }
7057
7058
7059 static PyObject * BusyInfo_swigregister(PyObject *, PyObject *args) {
7060 PyObject *obj;
7061 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7062 SWIG_TypeClientData(SWIGTYPE_p_wxBusyInfo, obj);
7063 Py_INCREF(obj);
7064 return Py_BuildValue((char *)"");
7065 }
7066 static PyObject *_wrap_new_StopWatch(PyObject *, PyObject *args, PyObject *kwargs) {
7067 PyObject *resultobj;
7068 wxStopWatch *result;
7069 char *kwnames[] = {
7070 NULL
7071 };
7072
7073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StopWatch",kwnames)) goto fail;
7074 {
7075 PyThreadState* __tstate = wxPyBeginAllowThreads();
7076 result = (wxStopWatch *)new wxStopWatch();
7077
7078 wxPyEndAllowThreads(__tstate);
7079 if (PyErr_Occurred()) SWIG_fail;
7080 }
7081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStopWatch, 1);
7082 return resultobj;
7083 fail:
7084 return NULL;
7085 }
7086
7087
7088 static PyObject *_wrap_StopWatch_Start(PyObject *, PyObject *args, PyObject *kwargs) {
7089 PyObject *resultobj;
7090 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7091 long arg2 = (long) 0 ;
7092 PyObject * obj0 = 0 ;
7093 PyObject * obj1 = 0 ;
7094 char *kwnames[] = {
7095 (char *) "self",(char *) "t0", NULL
7096 };
7097
7098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:StopWatch_Start",kwnames,&obj0,&obj1)) goto fail;
7099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7100 if (SWIG_arg_fail(1)) SWIG_fail;
7101 if (obj1) {
7102 {
7103 arg2 = (long)(SWIG_As_long(obj1));
7104 if (SWIG_arg_fail(2)) SWIG_fail;
7105 }
7106 }
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 (arg1)->Start(arg2);
7110
7111 wxPyEndAllowThreads(__tstate);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 Py_INCREF(Py_None); resultobj = Py_None;
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 static PyObject *_wrap_StopWatch_Pause(PyObject *, PyObject *args, PyObject *kwargs) {
7122 PyObject *resultobj;
7123 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7124 PyObject * obj0 = 0 ;
7125 char *kwnames[] = {
7126 (char *) "self", NULL
7127 };
7128
7129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Pause",kwnames,&obj0)) goto fail;
7130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7131 if (SWIG_arg_fail(1)) SWIG_fail;
7132 {
7133 PyThreadState* __tstate = wxPyBeginAllowThreads();
7134 (arg1)->Pause();
7135
7136 wxPyEndAllowThreads(__tstate);
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 Py_INCREF(Py_None); resultobj = Py_None;
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 static PyObject *_wrap_StopWatch_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
7147 PyObject *resultobj;
7148 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7149 PyObject * obj0 = 0 ;
7150 char *kwnames[] = {
7151 (char *) "self", NULL
7152 };
7153
7154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Resume",kwnames,&obj0)) goto fail;
7155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7156 if (SWIG_arg_fail(1)) SWIG_fail;
7157 {
7158 PyThreadState* __tstate = wxPyBeginAllowThreads();
7159 (arg1)->Resume();
7160
7161 wxPyEndAllowThreads(__tstate);
7162 if (PyErr_Occurred()) SWIG_fail;
7163 }
7164 Py_INCREF(Py_None); resultobj = Py_None;
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 static PyObject *_wrap_StopWatch_Time(PyObject *, PyObject *args, PyObject *kwargs) {
7172 PyObject *resultobj;
7173 wxStopWatch *arg1 = (wxStopWatch *) 0 ;
7174 long result;
7175 PyObject * obj0 = 0 ;
7176 char *kwnames[] = {
7177 (char *) "self", NULL
7178 };
7179
7180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StopWatch_Time",kwnames,&obj0)) goto fail;
7181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStopWatch, SWIG_POINTER_EXCEPTION | 0);
7182 if (SWIG_arg_fail(1)) SWIG_fail;
7183 {
7184 PyThreadState* __tstate = wxPyBeginAllowThreads();
7185 result = (long)((wxStopWatch const *)arg1)->Time();
7186
7187 wxPyEndAllowThreads(__tstate);
7188 if (PyErr_Occurred()) SWIG_fail;
7189 }
7190 {
7191 resultobj = SWIG_From_long((long)(result));
7192 }
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 static PyObject * StopWatch_swigregister(PyObject *, PyObject *args) {
7200 PyObject *obj;
7201 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7202 SWIG_TypeClientData(SWIGTYPE_p_wxStopWatch, obj);
7203 Py_INCREF(obj);
7204 return Py_BuildValue((char *)"");
7205 }
7206 static PyObject *_wrap_new_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj;
7208 int arg1 = (int) 9 ;
7209 int arg2 = (int) wxID_FILE1 ;
7210 wxFileHistory *result;
7211 PyObject * obj0 = 0 ;
7212 PyObject * obj1 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "maxFiles",(char *) "idBase", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FileHistory",kwnames,&obj0,&obj1)) goto fail;
7218 if (obj0) {
7219 {
7220 arg1 = (int)(SWIG_As_int(obj0));
7221 if (SWIG_arg_fail(1)) SWIG_fail;
7222 }
7223 }
7224 if (obj1) {
7225 {
7226 arg2 = (int)(SWIG_As_int(obj1));
7227 if (SWIG_arg_fail(2)) SWIG_fail;
7228 }
7229 }
7230 {
7231 PyThreadState* __tstate = wxPyBeginAllowThreads();
7232 result = (wxFileHistory *)new wxFileHistory(arg1,arg2);
7233
7234 wxPyEndAllowThreads(__tstate);
7235 if (PyErr_Occurred()) SWIG_fail;
7236 }
7237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileHistory, 1);
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_delete_FileHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7247 PyObject * obj0 = 0 ;
7248 char *kwnames[] = {
7249 (char *) "self", NULL
7250 };
7251
7252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileHistory",kwnames,&obj0)) goto fail;
7253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7254 if (SWIG_arg_fail(1)) SWIG_fail;
7255 {
7256 PyThreadState* __tstate = wxPyBeginAllowThreads();
7257 delete arg1;
7258
7259 wxPyEndAllowThreads(__tstate);
7260 if (PyErr_Occurred()) SWIG_fail;
7261 }
7262 Py_INCREF(Py_None); resultobj = Py_None;
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_FileHistory_AddFileToHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7272 wxString *arg2 = 0 ;
7273 bool temp2 = false ;
7274 PyObject * obj0 = 0 ;
7275 PyObject * obj1 = 0 ;
7276 char *kwnames[] = {
7277 (char *) "self",(char *) "file", NULL
7278 };
7279
7280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFileToHistory",kwnames,&obj0,&obj1)) goto fail;
7281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7282 if (SWIG_arg_fail(1)) SWIG_fail;
7283 {
7284 arg2 = wxString_in_helper(obj1);
7285 if (arg2 == NULL) SWIG_fail;
7286 temp2 = true;
7287 }
7288 {
7289 PyThreadState* __tstate = wxPyBeginAllowThreads();
7290 (arg1)->AddFileToHistory((wxString const &)*arg2);
7291
7292 wxPyEndAllowThreads(__tstate);
7293 if (PyErr_Occurred()) SWIG_fail;
7294 }
7295 Py_INCREF(Py_None); resultobj = Py_None;
7296 {
7297 if (temp2)
7298 delete arg2;
7299 }
7300 return resultobj;
7301 fail:
7302 {
7303 if (temp2)
7304 delete arg2;
7305 }
7306 return NULL;
7307 }
7308
7309
7310 static PyObject *_wrap_FileHistory_RemoveFileFromHistory(PyObject *, PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj;
7312 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7313 int arg2 ;
7314 PyObject * obj0 = 0 ;
7315 PyObject * obj1 = 0 ;
7316 char *kwnames[] = {
7317 (char *) "self",(char *) "i", NULL
7318 };
7319
7320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveFileFromHistory",kwnames,&obj0,&obj1)) goto fail;
7321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7322 if (SWIG_arg_fail(1)) SWIG_fail;
7323 {
7324 arg2 = (int)(SWIG_As_int(obj1));
7325 if (SWIG_arg_fail(2)) SWIG_fail;
7326 }
7327 {
7328 PyThreadState* __tstate = wxPyBeginAllowThreads();
7329 (arg1)->RemoveFileFromHistory(arg2);
7330
7331 wxPyEndAllowThreads(__tstate);
7332 if (PyErr_Occurred()) SWIG_fail;
7333 }
7334 Py_INCREF(Py_None); resultobj = Py_None;
7335 return resultobj;
7336 fail:
7337 return NULL;
7338 }
7339
7340
7341 static PyObject *_wrap_FileHistory_GetMaxFiles(PyObject *, PyObject *args, PyObject *kwargs) {
7342 PyObject *resultobj;
7343 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7344 int result;
7345 PyObject * obj0 = 0 ;
7346 char *kwnames[] = {
7347 (char *) "self", NULL
7348 };
7349
7350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetMaxFiles",kwnames,&obj0)) goto fail;
7351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7352 if (SWIG_arg_fail(1)) SWIG_fail;
7353 {
7354 PyThreadState* __tstate = wxPyBeginAllowThreads();
7355 result = (int)((wxFileHistory const *)arg1)->GetMaxFiles();
7356
7357 wxPyEndAllowThreads(__tstate);
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 {
7361 resultobj = SWIG_From_int((int)(result));
7362 }
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 static PyObject *_wrap_FileHistory_UseMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7372 wxMenu *arg2 = (wxMenu *) 0 ;
7373 PyObject * obj0 = 0 ;
7374 PyObject * obj1 = 0 ;
7375 char *kwnames[] = {
7376 (char *) "self",(char *) "menu", NULL
7377 };
7378
7379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_UseMenu",kwnames,&obj0,&obj1)) goto fail;
7380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7381 if (SWIG_arg_fail(1)) SWIG_fail;
7382 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7383 if (SWIG_arg_fail(2)) SWIG_fail;
7384 {
7385 PyThreadState* __tstate = wxPyBeginAllowThreads();
7386 (arg1)->UseMenu(arg2);
7387
7388 wxPyEndAllowThreads(__tstate);
7389 if (PyErr_Occurred()) SWIG_fail;
7390 }
7391 Py_INCREF(Py_None); resultobj = Py_None;
7392 return resultobj;
7393 fail:
7394 return NULL;
7395 }
7396
7397
7398 static PyObject *_wrap_FileHistory_RemoveMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7399 PyObject *resultobj;
7400 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7401 wxMenu *arg2 = (wxMenu *) 0 ;
7402 PyObject * obj0 = 0 ;
7403 PyObject * obj1 = 0 ;
7404 char *kwnames[] = {
7405 (char *) "self",(char *) "menu", NULL
7406 };
7407
7408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_RemoveMenu",kwnames,&obj0,&obj1)) goto fail;
7409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7410 if (SWIG_arg_fail(1)) SWIG_fail;
7411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7412 if (SWIG_arg_fail(2)) SWIG_fail;
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 (arg1)->RemoveMenu(arg2);
7416
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 Py_INCREF(Py_None); resultobj = Py_None;
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 static PyObject *_wrap_FileHistory_Load(PyObject *, PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj;
7429 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7430 wxConfigBase *arg2 = 0 ;
7431 PyObject * obj0 = 0 ;
7432 PyObject * obj1 = 0 ;
7433 char *kwnames[] = {
7434 (char *) "self",(char *) "config", NULL
7435 };
7436
7437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Load",kwnames,&obj0,&obj1)) goto fail;
7438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7439 if (SWIG_arg_fail(1)) SWIG_fail;
7440 {
7441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7442 if (SWIG_arg_fail(2)) SWIG_fail;
7443 if (arg2 == NULL) {
7444 SWIG_null_ref("wxConfigBase");
7445 }
7446 if (SWIG_arg_fail(2)) SWIG_fail;
7447 }
7448 {
7449 PyThreadState* __tstate = wxPyBeginAllowThreads();
7450 (arg1)->Load(*arg2);
7451
7452 wxPyEndAllowThreads(__tstate);
7453 if (PyErr_Occurred()) SWIG_fail;
7454 }
7455 Py_INCREF(Py_None); resultobj = Py_None;
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 static PyObject *_wrap_FileHistory_Save(PyObject *, PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj;
7464 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7465 wxConfigBase *arg2 = 0 ;
7466 PyObject * obj0 = 0 ;
7467 PyObject * obj1 = 0 ;
7468 char *kwnames[] = {
7469 (char *) "self",(char *) "config", NULL
7470 };
7471
7472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_Save",kwnames,&obj0,&obj1)) goto fail;
7473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7474 if (SWIG_arg_fail(1)) SWIG_fail;
7475 {
7476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
7477 if (SWIG_arg_fail(2)) SWIG_fail;
7478 if (arg2 == NULL) {
7479 SWIG_null_ref("wxConfigBase");
7480 }
7481 if (SWIG_arg_fail(2)) SWIG_fail;
7482 }
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 (arg1)->Save(*arg2);
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 Py_INCREF(Py_None); resultobj = Py_None;
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_FileHistory_AddFilesToMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7500 PyObject * obj0 = 0 ;
7501 char *kwnames[] = {
7502 (char *) "self", NULL
7503 };
7504
7505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_AddFilesToMenu",kwnames,&obj0)) goto fail;
7506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7507 if (SWIG_arg_fail(1)) SWIG_fail;
7508 {
7509 PyThreadState* __tstate = wxPyBeginAllowThreads();
7510 (arg1)->AddFilesToMenu();
7511
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 Py_INCREF(Py_None); resultobj = Py_None;
7516 return resultobj;
7517 fail:
7518 return NULL;
7519 }
7520
7521
7522 static PyObject *_wrap_FileHistory_AddFilesToThisMenu(PyObject *, PyObject *args, PyObject *kwargs) {
7523 PyObject *resultobj;
7524 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7525 wxMenu *arg2 = (wxMenu *) 0 ;
7526 PyObject * obj0 = 0 ;
7527 PyObject * obj1 = 0 ;
7528 char *kwnames[] = {
7529 (char *) "self",(char *) "menu", NULL
7530 };
7531
7532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_AddFilesToThisMenu",kwnames,&obj0,&obj1)) goto fail;
7533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7534 if (SWIG_arg_fail(1)) SWIG_fail;
7535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
7536 if (SWIG_arg_fail(2)) SWIG_fail;
7537 {
7538 PyThreadState* __tstate = wxPyBeginAllowThreads();
7539 (arg1)->AddFilesToMenu(arg2);
7540
7541 wxPyEndAllowThreads(__tstate);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 Py_INCREF(Py_None); resultobj = Py_None;
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 static PyObject *_wrap_FileHistory_GetHistoryFile(PyObject *, PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj;
7553 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7554 int arg2 ;
7555 wxString result;
7556 PyObject * obj0 = 0 ;
7557 PyObject * obj1 = 0 ;
7558 char *kwnames[] = {
7559 (char *) "self",(char *) "i", NULL
7560 };
7561
7562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileHistory_GetHistoryFile",kwnames,&obj0,&obj1)) goto fail;
7563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7564 if (SWIG_arg_fail(1)) SWIG_fail;
7565 {
7566 arg2 = (int)(SWIG_As_int(obj1));
7567 if (SWIG_arg_fail(2)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = ((wxFileHistory const *)arg1)->GetHistoryFile(arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 {
7577 #if wxUSE_UNICODE
7578 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7579 #else
7580 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7581 #endif
7582 }
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 static PyObject *_wrap_FileHistory_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj;
7591 wxFileHistory *arg1 = (wxFileHistory *) 0 ;
7592 int result;
7593 PyObject * obj0 = 0 ;
7594 char *kwnames[] = {
7595 (char *) "self", NULL
7596 };
7597
7598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileHistory_GetCount",kwnames,&obj0)) goto fail;
7599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileHistory, SWIG_POINTER_EXCEPTION | 0);
7600 if (SWIG_arg_fail(1)) SWIG_fail;
7601 {
7602 PyThreadState* __tstate = wxPyBeginAllowThreads();
7603 result = (int)((wxFileHistory const *)arg1)->GetCount();
7604
7605 wxPyEndAllowThreads(__tstate);
7606 if (PyErr_Occurred()) SWIG_fail;
7607 }
7608 {
7609 resultobj = SWIG_From_int((int)(result));
7610 }
7611 return resultobj;
7612 fail:
7613 return NULL;
7614 }
7615
7616
7617 static PyObject * FileHistory_swigregister(PyObject *, PyObject *args) {
7618 PyObject *obj;
7619 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7620 SWIG_TypeClientData(SWIGTYPE_p_wxFileHistory, obj);
7621 Py_INCREF(obj);
7622 return Py_BuildValue((char *)"");
7623 }
7624 static PyObject *_wrap_new_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj;
7626 wxString *arg1 = 0 ;
7627 wxString const &arg2_defvalue = wxPyEmptyString ;
7628 wxString *arg2 = (wxString *) &arg2_defvalue ;
7629 wxSingleInstanceChecker *result;
7630 bool temp1 = false ;
7631 bool temp2 = false ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char *kwnames[] = {
7635 (char *) "name",(char *) "path", NULL
7636 };
7637
7638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_SingleInstanceChecker",kwnames,&obj0,&obj1)) goto fail;
7639 {
7640 arg1 = wxString_in_helper(obj0);
7641 if (arg1 == NULL) SWIG_fail;
7642 temp1 = true;
7643 }
7644 if (obj1) {
7645 {
7646 arg2 = wxString_in_helper(obj1);
7647 if (arg2 == NULL) SWIG_fail;
7648 temp2 = true;
7649 }
7650 }
7651 {
7652 PyThreadState* __tstate = wxPyBeginAllowThreads();
7653 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker((wxString const &)*arg1,(wxString const &)*arg2);
7654
7655 wxPyEndAllowThreads(__tstate);
7656 if (PyErr_Occurred()) SWIG_fail;
7657 }
7658 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7659 {
7660 if (temp1)
7661 delete arg1;
7662 }
7663 {
7664 if (temp2)
7665 delete arg2;
7666 }
7667 return resultobj;
7668 fail:
7669 {
7670 if (temp1)
7671 delete arg1;
7672 }
7673 {
7674 if (temp2)
7675 delete arg2;
7676 }
7677 return NULL;
7678 }
7679
7680
7681 static PyObject *_wrap_new_PreSingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7682 PyObject *resultobj;
7683 wxSingleInstanceChecker *result;
7684 char *kwnames[] = {
7685 NULL
7686 };
7687
7688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreSingleInstanceChecker",kwnames)) goto fail;
7689 {
7690 PyThreadState* __tstate = wxPyBeginAllowThreads();
7691 result = (wxSingleInstanceChecker *)new wxSingleInstanceChecker();
7692
7693 wxPyEndAllowThreads(__tstate);
7694 if (PyErr_Occurred()) SWIG_fail;
7695 }
7696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSingleInstanceChecker, 1);
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 static PyObject *_wrap_delete_SingleInstanceChecker(PyObject *, PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj;
7705 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7706 PyObject * obj0 = 0 ;
7707 char *kwnames[] = {
7708 (char *) "self", NULL
7709 };
7710
7711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SingleInstanceChecker",kwnames,&obj0)) goto fail;
7712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7713 if (SWIG_arg_fail(1)) SWIG_fail;
7714 {
7715 PyThreadState* __tstate = wxPyBeginAllowThreads();
7716 delete arg1;
7717
7718 wxPyEndAllowThreads(__tstate);
7719 if (PyErr_Occurred()) SWIG_fail;
7720 }
7721 Py_INCREF(Py_None); resultobj = Py_None;
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 static PyObject *_wrap_SingleInstanceChecker_Create(PyObject *, PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj;
7730 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7731 wxString *arg2 = 0 ;
7732 wxString const &arg3_defvalue = wxPyEmptyString ;
7733 wxString *arg3 = (wxString *) &arg3_defvalue ;
7734 bool result;
7735 bool temp2 = false ;
7736 bool temp3 = false ;
7737 PyObject * obj0 = 0 ;
7738 PyObject * obj1 = 0 ;
7739 PyObject * obj2 = 0 ;
7740 char *kwnames[] = {
7741 (char *) "self",(char *) "name",(char *) "path", NULL
7742 };
7743
7744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:SingleInstanceChecker_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
7745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7746 if (SWIG_arg_fail(1)) SWIG_fail;
7747 {
7748 arg2 = wxString_in_helper(obj1);
7749 if (arg2 == NULL) SWIG_fail;
7750 temp2 = true;
7751 }
7752 if (obj2) {
7753 {
7754 arg3 = wxString_in_helper(obj2);
7755 if (arg3 == NULL) SWIG_fail;
7756 temp3 = true;
7757 }
7758 }
7759 {
7760 PyThreadState* __tstate = wxPyBeginAllowThreads();
7761 result = (bool)(arg1)->Create((wxString const &)*arg2,(wxString const &)*arg3);
7762
7763 wxPyEndAllowThreads(__tstate);
7764 if (PyErr_Occurred()) SWIG_fail;
7765 }
7766 {
7767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7768 }
7769 {
7770 if (temp2)
7771 delete arg2;
7772 }
7773 {
7774 if (temp3)
7775 delete arg3;
7776 }
7777 return resultobj;
7778 fail:
7779 {
7780 if (temp2)
7781 delete arg2;
7782 }
7783 {
7784 if (temp3)
7785 delete arg3;
7786 }
7787 return NULL;
7788 }
7789
7790
7791 static PyObject *_wrap_SingleInstanceChecker_IsAnotherRunning(PyObject *, PyObject *args, PyObject *kwargs) {
7792 PyObject *resultobj;
7793 wxSingleInstanceChecker *arg1 = (wxSingleInstanceChecker *) 0 ;
7794 bool result;
7795 PyObject * obj0 = 0 ;
7796 char *kwnames[] = {
7797 (char *) "self", NULL
7798 };
7799
7800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SingleInstanceChecker_IsAnotherRunning",kwnames,&obj0)) goto fail;
7801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSingleInstanceChecker, SWIG_POINTER_EXCEPTION | 0);
7802 if (SWIG_arg_fail(1)) SWIG_fail;
7803 {
7804 PyThreadState* __tstate = wxPyBeginAllowThreads();
7805 result = (bool)((wxSingleInstanceChecker const *)arg1)->IsAnotherRunning();
7806
7807 wxPyEndAllowThreads(__tstate);
7808 if (PyErr_Occurred()) SWIG_fail;
7809 }
7810 {
7811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7812 }
7813 return resultobj;
7814 fail:
7815 return NULL;
7816 }
7817
7818
7819 static PyObject * SingleInstanceChecker_swigregister(PyObject *, PyObject *args) {
7820 PyObject *obj;
7821 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7822 SWIG_TypeClientData(SWIGTYPE_p_wxSingleInstanceChecker, obj);
7823 Py_INCREF(obj);
7824 return Py_BuildValue((char *)"");
7825 }
7826 static PyObject *_wrap_DrawWindowOnDC(PyObject *, PyObject *args, PyObject *kwargs) {
7827 PyObject *resultobj;
7828 wxWindow *arg1 = (wxWindow *) 0 ;
7829 wxDC *arg2 = 0 ;
7830 bool result;
7831 PyObject * obj0 = 0 ;
7832 PyObject * obj1 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "window",(char *) "dc", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DrawWindowOnDC",kwnames,&obj0,&obj1)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
7842 if (SWIG_arg_fail(2)) SWIG_fail;
7843 if (arg2 == NULL) {
7844 SWIG_null_ref("wxDC");
7845 }
7846 if (SWIG_arg_fail(2)) SWIG_fail;
7847 }
7848 {
7849 PyThreadState* __tstate = wxPyBeginAllowThreads();
7850 result = (bool)wxDrawWindowOnDC(arg1,(wxDC const &)*arg2);
7851
7852 wxPyEndAllowThreads(__tstate);
7853 if (PyErr_Occurred()) SWIG_fail;
7854 }
7855 {
7856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7857 }
7858 return resultobj;
7859 fail:
7860 return NULL;
7861 }
7862
7863
7864 static PyObject *_wrap_delete_TipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
7865 PyObject *resultobj;
7866 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7867 PyObject * obj0 = 0 ;
7868 char *kwnames[] = {
7869 (char *) "self", NULL
7870 };
7871
7872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TipProvider",kwnames,&obj0)) goto fail;
7873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7874 if (SWIG_arg_fail(1)) SWIG_fail;
7875 {
7876 PyThreadState* __tstate = wxPyBeginAllowThreads();
7877 delete arg1;
7878
7879 wxPyEndAllowThreads(__tstate);
7880 if (PyErr_Occurred()) SWIG_fail;
7881 }
7882 Py_INCREF(Py_None); resultobj = Py_None;
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 static PyObject *_wrap_TipProvider_GetTip(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj;
7891 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7892 wxString result;
7893 PyObject * obj0 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "self", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetTip",kwnames,&obj0)) goto fail;
7899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7900 if (SWIG_arg_fail(1)) SWIG_fail;
7901 {
7902 PyThreadState* __tstate = wxPyBeginAllowThreads();
7903 result = (arg1)->GetTip();
7904
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 {
7909 #if wxUSE_UNICODE
7910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7911 #else
7912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7913 #endif
7914 }
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_TipProvider_GetCurrentTip(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj;
7923 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7924 size_t result;
7925 PyObject * obj0 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TipProvider_GetCurrentTip",kwnames,&obj0)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (size_t)(arg1)->GetCurrentTip();
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 static PyObject *_wrap_TipProvider_PreprocessTip(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj;
7951 wxTipProvider *arg1 = (wxTipProvider *) 0 ;
7952 wxString *arg2 = 0 ;
7953 wxString result;
7954 bool temp2 = false ;
7955 PyObject * obj0 = 0 ;
7956 PyObject * obj1 = 0 ;
7957 char *kwnames[] = {
7958 (char *) "self",(char *) "tip", NULL
7959 };
7960
7961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TipProvider_PreprocessTip",kwnames,&obj0,&obj1)) goto fail;
7962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
7963 if (SWIG_arg_fail(1)) SWIG_fail;
7964 {
7965 arg2 = wxString_in_helper(obj1);
7966 if (arg2 == NULL) SWIG_fail;
7967 temp2 = true;
7968 }
7969 {
7970 PyThreadState* __tstate = wxPyBeginAllowThreads();
7971 result = (arg1)->PreprocessTip((wxString const &)*arg2);
7972
7973 wxPyEndAllowThreads(__tstate);
7974 if (PyErr_Occurred()) SWIG_fail;
7975 }
7976 {
7977 #if wxUSE_UNICODE
7978 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
7979 #else
7980 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
7981 #endif
7982 }
7983 {
7984 if (temp2)
7985 delete arg2;
7986 }
7987 return resultobj;
7988 fail:
7989 {
7990 if (temp2)
7991 delete arg2;
7992 }
7993 return NULL;
7994 }
7995
7996
7997 static PyObject * TipProvider_swigregister(PyObject *, PyObject *args) {
7998 PyObject *obj;
7999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8000 SWIG_TypeClientData(SWIGTYPE_p_wxTipProvider, obj);
8001 Py_INCREF(obj);
8002 return Py_BuildValue((char *)"");
8003 }
8004 static PyObject *_wrap_new_PyTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8005 PyObject *resultobj;
8006 size_t arg1 ;
8007 wxPyTipProvider *result;
8008 PyObject * obj0 = 0 ;
8009 char *kwnames[] = {
8010 (char *) "currentTip", NULL
8011 };
8012
8013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PyTipProvider",kwnames,&obj0)) goto fail;
8014 {
8015 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
8016 if (SWIG_arg_fail(1)) SWIG_fail;
8017 }
8018 {
8019 PyThreadState* __tstate = wxPyBeginAllowThreads();
8020 result = (wxPyTipProvider *)new wxPyTipProvider(arg1);
8021
8022 wxPyEndAllowThreads(__tstate);
8023 if (PyErr_Occurred()) SWIG_fail;
8024 }
8025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTipProvider, 1);
8026 return resultobj;
8027 fail:
8028 return NULL;
8029 }
8030
8031
8032 static PyObject *_wrap_PyTipProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj;
8034 wxPyTipProvider *arg1 = (wxPyTipProvider *) 0 ;
8035 PyObject *arg2 = (PyObject *) 0 ;
8036 PyObject *arg3 = (PyObject *) 0 ;
8037 PyObject * obj0 = 0 ;
8038 PyObject * obj1 = 0 ;
8039 PyObject * obj2 = 0 ;
8040 char *kwnames[] = {
8041 (char *) "self",(char *) "self",(char *) "_class", NULL
8042 };
8043
8044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTipProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTipProvider, SWIG_POINTER_EXCEPTION | 0);
8046 if (SWIG_arg_fail(1)) SWIG_fail;
8047 arg2 = obj1;
8048 arg3 = obj2;
8049 {
8050 PyThreadState* __tstate = wxPyBeginAllowThreads();
8051 (arg1)->_setCallbackInfo(arg2,arg3);
8052
8053 wxPyEndAllowThreads(__tstate);
8054 if (PyErr_Occurred()) SWIG_fail;
8055 }
8056 Py_INCREF(Py_None); resultobj = Py_None;
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 static PyObject * PyTipProvider_swigregister(PyObject *, PyObject *args) {
8064 PyObject *obj;
8065 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8066 SWIG_TypeClientData(SWIGTYPE_p_wxPyTipProvider, obj);
8067 Py_INCREF(obj);
8068 return Py_BuildValue((char *)"");
8069 }
8070 static PyObject *_wrap_ShowTip(PyObject *, PyObject *args, PyObject *kwargs) {
8071 PyObject *resultobj;
8072 wxWindow *arg1 = (wxWindow *) 0 ;
8073 wxTipProvider *arg2 = (wxTipProvider *) 0 ;
8074 bool arg3 = (bool) true ;
8075 bool result;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 PyObject * obj2 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "parent",(char *) "tipProvider",(char *) "showAtStartup", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ShowTip",kwnames,&obj0,&obj1,&obj2)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTipProvider, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(2)) SWIG_fail;
8088 if (obj2) {
8089 {
8090 arg3 = (bool)(SWIG_As_bool(obj2));
8091 if (SWIG_arg_fail(3)) SWIG_fail;
8092 }
8093 }
8094 {
8095 if (!wxPyCheckForApp()) SWIG_fail;
8096 PyThreadState* __tstate = wxPyBeginAllowThreads();
8097 result = (bool)wxShowTip(arg1,arg2,arg3);
8098
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 {
8103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8104 }
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject *_wrap_CreateFileTipProvider(PyObject *, PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj;
8113 wxString *arg1 = 0 ;
8114 size_t arg2 ;
8115 wxTipProvider *result;
8116 bool temp1 = false ;
8117 PyObject * obj0 = 0 ;
8118 PyObject * obj1 = 0 ;
8119 char *kwnames[] = {
8120 (char *) "filename",(char *) "currentTip", NULL
8121 };
8122
8123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CreateFileTipProvider",kwnames,&obj0,&obj1)) goto fail;
8124 {
8125 arg1 = wxString_in_helper(obj0);
8126 if (arg1 == NULL) SWIG_fail;
8127 temp1 = true;
8128 }
8129 {
8130 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
8131 if (SWIG_arg_fail(2)) SWIG_fail;
8132 }
8133 {
8134 if (!wxPyCheckForApp()) SWIG_fail;
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 result = (wxTipProvider *)wxCreateFileTipProvider((wxString const &)*arg1,arg2);
8137
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTipProvider, 1);
8142 {
8143 if (temp1)
8144 delete arg1;
8145 }
8146 return resultobj;
8147 fail:
8148 {
8149 if (temp1)
8150 delete arg1;
8151 }
8152 return NULL;
8153 }
8154
8155
8156 static PyObject *_wrap_new_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8157 PyObject *resultobj;
8158 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
8159 int arg2 = (int) -1 ;
8160 wxPyTimer *result;
8161 PyObject * obj0 = 0 ;
8162 PyObject * obj1 = 0 ;
8163 char *kwnames[] = {
8164 (char *) "owner",(char *) "id", NULL
8165 };
8166
8167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Timer",kwnames,&obj0,&obj1)) goto fail;
8168 if (obj0) {
8169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8170 if (SWIG_arg_fail(1)) SWIG_fail;
8171 }
8172 if (obj1) {
8173 {
8174 arg2 = (int)(SWIG_As_int(obj1));
8175 if (SWIG_arg_fail(2)) SWIG_fail;
8176 }
8177 }
8178 {
8179 if (!wxPyCheckForApp()) SWIG_fail;
8180 PyThreadState* __tstate = wxPyBeginAllowThreads();
8181 result = (wxPyTimer *)new wxPyTimer(arg1,arg2);
8182
8183 wxPyEndAllowThreads(__tstate);
8184 if (PyErr_Occurred()) SWIG_fail;
8185 }
8186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTimer, 1);
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject *_wrap_delete_Timer(PyObject *, PyObject *args, PyObject *kwargs) {
8194 PyObject *resultobj;
8195 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8196 PyObject * obj0 = 0 ;
8197 char *kwnames[] = {
8198 (char *) "self", NULL
8199 };
8200
8201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Timer",kwnames,&obj0)) goto fail;
8202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8203 if (SWIG_arg_fail(1)) SWIG_fail;
8204 {
8205 PyThreadState* __tstate = wxPyBeginAllowThreads();
8206 delete arg1;
8207
8208 wxPyEndAllowThreads(__tstate);
8209 if (PyErr_Occurred()) SWIG_fail;
8210 }
8211 Py_INCREF(Py_None); resultobj = Py_None;
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 static PyObject *_wrap_Timer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8219 PyObject *resultobj;
8220 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8221 PyObject *arg2 = (PyObject *) 0 ;
8222 PyObject *arg3 = (PyObject *) 0 ;
8223 int arg4 = (int) 1 ;
8224 PyObject * obj0 = 0 ;
8225 PyObject * obj1 = 0 ;
8226 PyObject * obj2 = 0 ;
8227 PyObject * obj3 = 0 ;
8228 char *kwnames[] = {
8229 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
8230 };
8231
8232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Timer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
8233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8234 if (SWIG_arg_fail(1)) SWIG_fail;
8235 arg2 = obj1;
8236 arg3 = obj2;
8237 if (obj3) {
8238 {
8239 arg4 = (int)(SWIG_As_int(obj3));
8240 if (SWIG_arg_fail(4)) SWIG_fail;
8241 }
8242 }
8243 {
8244 PyThreadState* __tstate = wxPyBeginAllowThreads();
8245 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
8246
8247 wxPyEndAllowThreads(__tstate);
8248 if (PyErr_Occurred()) SWIG_fail;
8249 }
8250 Py_INCREF(Py_None); resultobj = Py_None;
8251 return resultobj;
8252 fail:
8253 return NULL;
8254 }
8255
8256
8257 static PyObject *_wrap_Timer_SetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8258 PyObject *resultobj;
8259 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8260 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
8261 int arg3 = (int) -1 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 PyObject * obj2 = 0 ;
8265 char *kwnames[] = {
8266 (char *) "self",(char *) "owner",(char *) "id", NULL
8267 };
8268
8269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Timer_SetOwner",kwnames,&obj0,&obj1,&obj2)) goto fail;
8270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8271 if (SWIG_arg_fail(1)) SWIG_fail;
8272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
8273 if (SWIG_arg_fail(2)) SWIG_fail;
8274 if (obj2) {
8275 {
8276 arg3 = (int)(SWIG_As_int(obj2));
8277 if (SWIG_arg_fail(3)) SWIG_fail;
8278 }
8279 }
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 (arg1)->SetOwner(arg2,arg3);
8283
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 Py_INCREF(Py_None); resultobj = Py_None;
8288 return resultobj;
8289 fail:
8290 return NULL;
8291 }
8292
8293
8294 static PyObject *_wrap_Timer_GetOwner(PyObject *, PyObject *args, PyObject *kwargs) {
8295 PyObject *resultobj;
8296 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8297 wxEvtHandler *result;
8298 PyObject * obj0 = 0 ;
8299 char *kwnames[] = {
8300 (char *) "self", NULL
8301 };
8302
8303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetOwner",kwnames,&obj0)) goto fail;
8304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8305 if (SWIG_arg_fail(1)) SWIG_fail;
8306 {
8307 PyThreadState* __tstate = wxPyBeginAllowThreads();
8308 result = (wxEvtHandler *)(arg1)->GetOwner();
8309
8310 wxPyEndAllowThreads(__tstate);
8311 if (PyErr_Occurred()) SWIG_fail;
8312 }
8313 {
8314 resultobj = wxPyMake_wxObject(result, 0);
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 static PyObject *_wrap_Timer_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj;
8324 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8325 int arg2 = (int) -1 ;
8326 bool arg3 = (bool) false ;
8327 bool result;
8328 PyObject * obj0 = 0 ;
8329 PyObject * obj1 = 0 ;
8330 PyObject * obj2 = 0 ;
8331 char *kwnames[] = {
8332 (char *) "self",(char *) "milliseconds",(char *) "oneShot", NULL
8333 };
8334
8335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Timer_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8337 if (SWIG_arg_fail(1)) SWIG_fail;
8338 if (obj1) {
8339 {
8340 arg2 = (int)(SWIG_As_int(obj1));
8341 if (SWIG_arg_fail(2)) SWIG_fail;
8342 }
8343 }
8344 if (obj2) {
8345 {
8346 arg3 = (bool)(SWIG_As_bool(obj2));
8347 if (SWIG_arg_fail(3)) SWIG_fail;
8348 }
8349 }
8350 {
8351 PyThreadState* __tstate = wxPyBeginAllowThreads();
8352 result = (bool)(arg1)->Start(arg2,arg3);
8353
8354 wxPyEndAllowThreads(__tstate);
8355 if (PyErr_Occurred()) SWIG_fail;
8356 }
8357 {
8358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8359 }
8360 return resultobj;
8361 fail:
8362 return NULL;
8363 }
8364
8365
8366 static PyObject *_wrap_Timer_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
8367 PyObject *resultobj;
8368 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8369 PyObject * obj0 = 0 ;
8370 char *kwnames[] = {
8371 (char *) "self", NULL
8372 };
8373
8374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_Stop",kwnames,&obj0)) goto fail;
8375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(1)) SWIG_fail;
8377 {
8378 PyThreadState* __tstate = wxPyBeginAllowThreads();
8379 (arg1)->Stop();
8380
8381 wxPyEndAllowThreads(__tstate);
8382 if (PyErr_Occurred()) SWIG_fail;
8383 }
8384 Py_INCREF(Py_None); resultobj = Py_None;
8385 return resultobj;
8386 fail:
8387 return NULL;
8388 }
8389
8390
8391 static PyObject *_wrap_Timer_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
8392 PyObject *resultobj;
8393 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8394 bool result;
8395 PyObject * obj0 = 0 ;
8396 char *kwnames[] = {
8397 (char *) "self", NULL
8398 };
8399
8400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsRunning",kwnames,&obj0)) goto fail;
8401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8402 if (SWIG_arg_fail(1)) SWIG_fail;
8403 {
8404 PyThreadState* __tstate = wxPyBeginAllowThreads();
8405 result = (bool)((wxPyTimer const *)arg1)->IsRunning();
8406
8407 wxPyEndAllowThreads(__tstate);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 {
8411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8412 }
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_Timer_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj;
8421 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8422 int result;
8423 PyObject * obj0 = 0 ;
8424 char *kwnames[] = {
8425 (char *) "self", NULL
8426 };
8427
8428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetInterval",kwnames,&obj0)) goto fail;
8429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8430 if (SWIG_arg_fail(1)) SWIG_fail;
8431 {
8432 PyThreadState* __tstate = wxPyBeginAllowThreads();
8433 result = (int)((wxPyTimer const *)arg1)->GetInterval();
8434
8435 wxPyEndAllowThreads(__tstate);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 {
8439 resultobj = SWIG_From_int((int)(result));
8440 }
8441 return resultobj;
8442 fail:
8443 return NULL;
8444 }
8445
8446
8447 static PyObject *_wrap_Timer_IsOneShot(PyObject *, PyObject *args, PyObject *kwargs) {
8448 PyObject *resultobj;
8449 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8450 bool result;
8451 PyObject * obj0 = 0 ;
8452 char *kwnames[] = {
8453 (char *) "self", NULL
8454 };
8455
8456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_IsOneShot",kwnames,&obj0)) goto fail;
8457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8458 if (SWIG_arg_fail(1)) SWIG_fail;
8459 {
8460 PyThreadState* __tstate = wxPyBeginAllowThreads();
8461 result = (bool)((wxPyTimer const *)arg1)->IsOneShot();
8462
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 {
8467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8468 }
8469 return resultobj;
8470 fail:
8471 return NULL;
8472 }
8473
8474
8475 static PyObject *_wrap_Timer_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
8476 PyObject *resultobj;
8477 wxPyTimer *arg1 = (wxPyTimer *) 0 ;
8478 int result;
8479 PyObject * obj0 = 0 ;
8480 char *kwnames[] = {
8481 (char *) "self", NULL
8482 };
8483
8484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Timer_GetId",kwnames,&obj0)) goto fail;
8485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTimer, SWIG_POINTER_EXCEPTION | 0);
8486 if (SWIG_arg_fail(1)) SWIG_fail;
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (int)((wxPyTimer const *)arg1)->GetId();
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 resultobj = SWIG_From_int((int)(result));
8496 }
8497 return resultobj;
8498 fail:
8499 return NULL;
8500 }
8501
8502
8503 static PyObject * Timer_swigregister(PyObject *, PyObject *args) {
8504 PyObject *obj;
8505 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8506 SWIG_TypeClientData(SWIGTYPE_p_wxPyTimer, obj);
8507 Py_INCREF(obj);
8508 return Py_BuildValue((char *)"");
8509 }
8510 static PyObject *_wrap_new_TimerEvent(PyObject *, PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj;
8512 int arg1 = (int) 0 ;
8513 int arg2 = (int) 0 ;
8514 wxTimerEvent *result;
8515 PyObject * obj0 = 0 ;
8516 PyObject * obj1 = 0 ;
8517 char *kwnames[] = {
8518 (char *) "timerid",(char *) "interval", NULL
8519 };
8520
8521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_TimerEvent",kwnames,&obj0,&obj1)) goto fail;
8522 if (obj0) {
8523 {
8524 arg1 = (int)(SWIG_As_int(obj0));
8525 if (SWIG_arg_fail(1)) SWIG_fail;
8526 }
8527 }
8528 if (obj1) {
8529 {
8530 arg2 = (int)(SWIG_As_int(obj1));
8531 if (SWIG_arg_fail(2)) SWIG_fail;
8532 }
8533 }
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (wxTimerEvent *)new wxTimerEvent(arg1,arg2);
8537
8538 wxPyEndAllowThreads(__tstate);
8539 if (PyErr_Occurred()) SWIG_fail;
8540 }
8541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerEvent, 1);
8542 return resultobj;
8543 fail:
8544 return NULL;
8545 }
8546
8547
8548 static PyObject *_wrap_TimerEvent_GetInterval(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj;
8550 wxTimerEvent *arg1 = (wxTimerEvent *) 0 ;
8551 int result;
8552 PyObject * obj0 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimerEvent_GetInterval",kwnames,&obj0)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerEvent, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (int)((wxTimerEvent const *)arg1)->GetInterval();
8563
8564 wxPyEndAllowThreads(__tstate);
8565 if (PyErr_Occurred()) SWIG_fail;
8566 }
8567 {
8568 resultobj = SWIG_From_int((int)(result));
8569 }
8570 return resultobj;
8571 fail:
8572 return NULL;
8573 }
8574
8575
8576 static PyObject * TimerEvent_swigregister(PyObject *, PyObject *args) {
8577 PyObject *obj;
8578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8579 SWIG_TypeClientData(SWIGTYPE_p_wxTimerEvent, obj);
8580 Py_INCREF(obj);
8581 return Py_BuildValue((char *)"");
8582 }
8583 static PyObject *_wrap_new_TimerRunner__SWIG_0(PyObject *, PyObject *args) {
8584 PyObject *resultobj;
8585 wxTimer *arg1 = 0 ;
8586 wxTimerRunner *result;
8587 PyObject * obj0 = 0 ;
8588
8589 if(!PyArg_ParseTuple(args,(char *)"O:new_TimerRunner",&obj0)) goto fail;
8590 {
8591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8592 if (SWIG_arg_fail(1)) SWIG_fail;
8593 if (arg1 == NULL) {
8594 SWIG_null_ref("wxTimer");
8595 }
8596 if (SWIG_arg_fail(1)) SWIG_fail;
8597 }
8598 {
8599 if (!wxPyCheckForApp()) SWIG_fail;
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 result = (wxTimerRunner *)new wxTimerRunner(*arg1);
8602
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 static PyObject *_wrap_new_TimerRunner__SWIG_1(PyObject *, PyObject *args) {
8614 PyObject *resultobj;
8615 wxTimer *arg1 = 0 ;
8616 int arg2 ;
8617 bool arg3 = (bool) false ;
8618 wxTimerRunner *result;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 PyObject * obj2 = 0 ;
8622
8623 if(!PyArg_ParseTuple(args,(char *)"OO|O:new_TimerRunner",&obj0,&obj1,&obj2)) goto fail;
8624 {
8625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimer, SWIG_POINTER_EXCEPTION | 0);
8626 if (SWIG_arg_fail(1)) SWIG_fail;
8627 if (arg1 == NULL) {
8628 SWIG_null_ref("wxTimer");
8629 }
8630 if (SWIG_arg_fail(1)) SWIG_fail;
8631 }
8632 {
8633 arg2 = (int)(SWIG_As_int(obj1));
8634 if (SWIG_arg_fail(2)) SWIG_fail;
8635 }
8636 if (obj2) {
8637 {
8638 arg3 = (bool)(SWIG_As_bool(obj2));
8639 if (SWIG_arg_fail(3)) SWIG_fail;
8640 }
8641 }
8642 {
8643 if (!wxPyCheckForApp()) SWIG_fail;
8644 PyThreadState* __tstate = wxPyBeginAllowThreads();
8645 result = (wxTimerRunner *)new wxTimerRunner(*arg1,arg2,arg3);
8646
8647 wxPyEndAllowThreads(__tstate);
8648 if (PyErr_Occurred()) SWIG_fail;
8649 }
8650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimerRunner, 1);
8651 return resultobj;
8652 fail:
8653 return NULL;
8654 }
8655
8656
8657 static PyObject *_wrap_new_TimerRunner(PyObject *self, PyObject *args) {
8658 int argc;
8659 PyObject *argv[4];
8660 int ii;
8661
8662 argc = PyObject_Length(args);
8663 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
8664 argv[ii] = PyTuple_GetItem(args,ii);
8665 }
8666 if (argc == 1) {
8667 int _v;
8668 {
8669 void *ptr = 0;
8670 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8671 _v = 0;
8672 PyErr_Clear();
8673 } else {
8674 _v = (ptr != 0);
8675 }
8676 }
8677 if (_v) {
8678 return _wrap_new_TimerRunner__SWIG_0(self,args);
8679 }
8680 }
8681 if ((argc >= 2) && (argc <= 3)) {
8682 int _v;
8683 {
8684 void *ptr = 0;
8685 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxTimer, 0) == -1) {
8686 _v = 0;
8687 PyErr_Clear();
8688 } else {
8689 _v = (ptr != 0);
8690 }
8691 }
8692 if (_v) {
8693 _v = SWIG_Check_int(argv[1]);
8694 if (_v) {
8695 if (argc <= 2) {
8696 return _wrap_new_TimerRunner__SWIG_1(self,args);
8697 }
8698 _v = SWIG_Check_bool(argv[2]);
8699 if (_v) {
8700 return _wrap_new_TimerRunner__SWIG_1(self,args);
8701 }
8702 }
8703 }
8704 }
8705
8706 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_TimerRunner'");
8707 return NULL;
8708 }
8709
8710
8711 static PyObject *_wrap_delete_TimerRunner(PyObject *, PyObject *args, PyObject *kwargs) {
8712 PyObject *resultobj;
8713 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8714 PyObject * obj0 = 0 ;
8715 char *kwnames[] = {
8716 (char *) "self", NULL
8717 };
8718
8719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimerRunner",kwnames,&obj0)) goto fail;
8720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8721 if (SWIG_arg_fail(1)) SWIG_fail;
8722 {
8723 PyThreadState* __tstate = wxPyBeginAllowThreads();
8724 delete arg1;
8725
8726 wxPyEndAllowThreads(__tstate);
8727 if (PyErr_Occurred()) SWIG_fail;
8728 }
8729 Py_INCREF(Py_None); resultobj = Py_None;
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_TimerRunner_Start(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj;
8738 wxTimerRunner *arg1 = (wxTimerRunner *) 0 ;
8739 int arg2 ;
8740 bool arg3 = (bool) false ;
8741 PyObject * obj0 = 0 ;
8742 PyObject * obj1 = 0 ;
8743 PyObject * obj2 = 0 ;
8744 char *kwnames[] = {
8745 (char *) "self",(char *) "milli",(char *) "oneShot", NULL
8746 };
8747
8748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:TimerRunner_Start",kwnames,&obj0,&obj1,&obj2)) goto fail;
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimerRunner, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 {
8752 arg2 = (int)(SWIG_As_int(obj1));
8753 if (SWIG_arg_fail(2)) SWIG_fail;
8754 }
8755 if (obj2) {
8756 {
8757 arg3 = (bool)(SWIG_As_bool(obj2));
8758 if (SWIG_arg_fail(3)) SWIG_fail;
8759 }
8760 }
8761 {
8762 PyThreadState* __tstate = wxPyBeginAllowThreads();
8763 (arg1)->Start(arg2,arg3);
8764
8765 wxPyEndAllowThreads(__tstate);
8766 if (PyErr_Occurred()) SWIG_fail;
8767 }
8768 Py_INCREF(Py_None); resultobj = Py_None;
8769 return resultobj;
8770 fail:
8771 return NULL;
8772 }
8773
8774
8775 static PyObject * TimerRunner_swigregister(PyObject *, PyObject *args) {
8776 PyObject *obj;
8777 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8778 SWIG_TypeClientData(SWIGTYPE_p_wxTimerRunner, obj);
8779 Py_INCREF(obj);
8780 return Py_BuildValue((char *)"");
8781 }
8782 static PyObject *_wrap_new_Log(PyObject *, PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj;
8784 wxLog *result;
8785 char *kwnames[] = {
8786 NULL
8787 };
8788
8789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Log",kwnames)) goto fail;
8790 {
8791 PyThreadState* __tstate = wxPyBeginAllowThreads();
8792 result = (wxLog *)new wxLog();
8793
8794 wxPyEndAllowThreads(__tstate);
8795 if (PyErr_Occurred()) SWIG_fail;
8796 }
8797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 1);
8798 return resultobj;
8799 fail:
8800 return NULL;
8801 }
8802
8803
8804 static PyObject *_wrap_Log_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
8805 PyObject *resultobj;
8806 bool result;
8807 char *kwnames[] = {
8808 NULL
8809 };
8810
8811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_IsEnabled",kwnames)) goto fail;
8812 {
8813 PyThreadState* __tstate = wxPyBeginAllowThreads();
8814 result = (bool)wxLog::IsEnabled();
8815
8816 wxPyEndAllowThreads(__tstate);
8817 if (PyErr_Occurred()) SWIG_fail;
8818 }
8819 {
8820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8821 }
8822 return resultobj;
8823 fail:
8824 return NULL;
8825 }
8826
8827
8828 static PyObject *_wrap_Log_EnableLogging(PyObject *, PyObject *args, PyObject *kwargs) {
8829 PyObject *resultobj;
8830 bool arg1 = (bool) true ;
8831 bool result;
8832 PyObject * obj0 = 0 ;
8833 char *kwnames[] = {
8834 (char *) "doIt", NULL
8835 };
8836
8837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_EnableLogging",kwnames,&obj0)) goto fail;
8838 if (obj0) {
8839 {
8840 arg1 = (bool)(SWIG_As_bool(obj0));
8841 if (SWIG_arg_fail(1)) SWIG_fail;
8842 }
8843 }
8844 {
8845 PyThreadState* __tstate = wxPyBeginAllowThreads();
8846 result = (bool)wxLog::EnableLogging(arg1);
8847
8848 wxPyEndAllowThreads(__tstate);
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 {
8852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8853 }
8854 return resultobj;
8855 fail:
8856 return NULL;
8857 }
8858
8859
8860 static PyObject *_wrap_Log_OnLog(PyObject *, PyObject *args, PyObject *kwargs) {
8861 PyObject *resultobj;
8862 wxLogLevel arg1 ;
8863 wxChar *arg2 = (wxChar *) 0 ;
8864 time_t arg3 ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 PyObject * obj2 = 0 ;
8868 char *kwnames[] = {
8869 (char *) "level",(char *) "szString",(char *) "t", NULL
8870 };
8871
8872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Log_OnLog",kwnames,&obj0,&obj1,&obj2)) goto fail;
8873 {
8874 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
8875 if (SWIG_arg_fail(1)) SWIG_fail;
8876 }
8877 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
8878 if (SWIG_arg_fail(2)) SWIG_fail;
8879 {
8880 arg3 = (time_t)(SWIG_As_unsigned_SS_int(obj2));
8881 if (SWIG_arg_fail(3)) SWIG_fail;
8882 }
8883 {
8884 PyThreadState* __tstate = wxPyBeginAllowThreads();
8885 wxLog::OnLog(arg1,(wxChar const *)arg2,arg3);
8886
8887 wxPyEndAllowThreads(__tstate);
8888 if (PyErr_Occurred()) SWIG_fail;
8889 }
8890 Py_INCREF(Py_None); resultobj = Py_None;
8891 return resultobj;
8892 fail:
8893 return NULL;
8894 }
8895
8896
8897 static PyObject *_wrap_Log_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
8898 PyObject *resultobj;
8899 wxLog *arg1 = (wxLog *) 0 ;
8900 PyObject * obj0 = 0 ;
8901 char *kwnames[] = {
8902 (char *) "self", NULL
8903 };
8904
8905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Flush",kwnames,&obj0)) goto fail;
8906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8907 if (SWIG_arg_fail(1)) SWIG_fail;
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 (arg1)->Flush();
8911
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 Py_INCREF(Py_None); resultobj = Py_None;
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 static PyObject *_wrap_Log_FlushActive(PyObject *, PyObject *args, PyObject *kwargs) {
8923 PyObject *resultobj;
8924 char *kwnames[] = {
8925 NULL
8926 };
8927
8928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_FlushActive",kwnames)) goto fail;
8929 {
8930 PyThreadState* __tstate = wxPyBeginAllowThreads();
8931 wxLog::FlushActive();
8932
8933 wxPyEndAllowThreads(__tstate);
8934 if (PyErr_Occurred()) SWIG_fail;
8935 }
8936 Py_INCREF(Py_None); resultobj = Py_None;
8937 return resultobj;
8938 fail:
8939 return NULL;
8940 }
8941
8942
8943 static PyObject *_wrap_Log_GetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8944 PyObject *resultobj;
8945 wxLog *result;
8946 char *kwnames[] = {
8947 NULL
8948 };
8949
8950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetActiveTarget",kwnames)) goto fail;
8951 {
8952 PyThreadState* __tstate = wxPyBeginAllowThreads();
8953 result = (wxLog *)wxLog::GetActiveTarget();
8954
8955 wxPyEndAllowThreads(__tstate);
8956 if (PyErr_Occurred()) SWIG_fail;
8957 }
8958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8959 return resultobj;
8960 fail:
8961 return NULL;
8962 }
8963
8964
8965 static PyObject *_wrap_Log_SetActiveTarget(PyObject *, PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj;
8967 wxLog *arg1 = (wxLog *) 0 ;
8968 wxLog *result;
8969 PyObject * obj0 = 0 ;
8970 char *kwnames[] = {
8971 (char *) "pLogger", NULL
8972 };
8973
8974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetActiveTarget",kwnames,&obj0)) goto fail;
8975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
8976 if (SWIG_arg_fail(1)) SWIG_fail;
8977 {
8978 PyThreadState* __tstate = wxPyBeginAllowThreads();
8979 result = (wxLog *)wxLog::SetActiveTarget(arg1);
8980
8981 wxPyEndAllowThreads(__tstate);
8982 if (PyErr_Occurred()) SWIG_fail;
8983 }
8984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
8985 return resultobj;
8986 fail:
8987 return NULL;
8988 }
8989
8990
8991 static PyObject *_wrap_Log_Suspend(PyObject *, PyObject *args, PyObject *kwargs) {
8992 PyObject *resultobj;
8993 char *kwnames[] = {
8994 NULL
8995 };
8996
8997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Suspend",kwnames)) goto fail;
8998 {
8999 PyThreadState* __tstate = wxPyBeginAllowThreads();
9000 wxLog::Suspend();
9001
9002 wxPyEndAllowThreads(__tstate);
9003 if (PyErr_Occurred()) SWIG_fail;
9004 }
9005 Py_INCREF(Py_None); resultobj = Py_None;
9006 return resultobj;
9007 fail:
9008 return NULL;
9009 }
9010
9011
9012 static PyObject *_wrap_Log_Resume(PyObject *, PyObject *args, PyObject *kwargs) {
9013 PyObject *resultobj;
9014 char *kwnames[] = {
9015 NULL
9016 };
9017
9018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_Resume",kwnames)) goto fail;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 wxLog::Resume();
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 Py_INCREF(Py_None); resultobj = Py_None;
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_Log_SetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 bool arg1 = (bool) true ;
9036 PyObject * obj0 = 0 ;
9037 char *kwnames[] = {
9038 (char *) "bVerbose", NULL
9039 };
9040
9041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Log_SetVerbose",kwnames,&obj0)) goto fail;
9042 if (obj0) {
9043 {
9044 arg1 = (bool)(SWIG_As_bool(obj0));
9045 if (SWIG_arg_fail(1)) SWIG_fail;
9046 }
9047 }
9048 {
9049 PyThreadState* __tstate = wxPyBeginAllowThreads();
9050 wxLog::SetVerbose(arg1);
9051
9052 wxPyEndAllowThreads(__tstate);
9053 if (PyErr_Occurred()) SWIG_fail;
9054 }
9055 Py_INCREF(Py_None); resultobj = Py_None;
9056 return resultobj;
9057 fail:
9058 return NULL;
9059 }
9060
9061
9062 static PyObject *_wrap_Log_SetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9063 PyObject *resultobj;
9064 wxLogLevel arg1 ;
9065 PyObject * obj0 = 0 ;
9066 char *kwnames[] = {
9067 (char *) "logLevel", NULL
9068 };
9069
9070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetLogLevel",kwnames,&obj0)) goto fail;
9071 {
9072 arg1 = (wxLogLevel)(SWIG_As_unsigned_SS_long(obj0));
9073 if (SWIG_arg_fail(1)) SWIG_fail;
9074 }
9075 {
9076 PyThreadState* __tstate = wxPyBeginAllowThreads();
9077 wxLog::SetLogLevel(arg1);
9078
9079 wxPyEndAllowThreads(__tstate);
9080 if (PyErr_Occurred()) SWIG_fail;
9081 }
9082 Py_INCREF(Py_None); resultobj = Py_None;
9083 return resultobj;
9084 fail:
9085 return NULL;
9086 }
9087
9088
9089 static PyObject *_wrap_Log_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
9090 PyObject *resultobj;
9091 char *kwnames[] = {
9092 NULL
9093 };
9094
9095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_DontCreateOnDemand",kwnames)) goto fail;
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 wxLog::DontCreateOnDemand();
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 Py_INCREF(Py_None); resultobj = Py_None;
9104 return resultobj;
9105 fail:
9106 return NULL;
9107 }
9108
9109
9110 static PyObject *_wrap_Log_SetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9111 PyObject *resultobj;
9112 wxTraceMask arg1 ;
9113 PyObject * obj0 = 0 ;
9114 char *kwnames[] = {
9115 (char *) "ulMask", NULL
9116 };
9117
9118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTraceMask",kwnames,&obj0)) goto fail;
9119 {
9120 arg1 = (wxTraceMask)(SWIG_As_unsigned_SS_long(obj0));
9121 if (SWIG_arg_fail(1)) SWIG_fail;
9122 }
9123 {
9124 PyThreadState* __tstate = wxPyBeginAllowThreads();
9125 wxLog::SetTraceMask(arg1);
9126
9127 wxPyEndAllowThreads(__tstate);
9128 if (PyErr_Occurred()) SWIG_fail;
9129 }
9130 Py_INCREF(Py_None); resultobj = Py_None;
9131 return resultobj;
9132 fail:
9133 return NULL;
9134 }
9135
9136
9137 static PyObject *_wrap_Log_AddTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9138 PyObject *resultobj;
9139 wxString *arg1 = 0 ;
9140 bool temp1 = false ;
9141 PyObject * obj0 = 0 ;
9142 char *kwnames[] = {
9143 (char *) "str", NULL
9144 };
9145
9146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_AddTraceMask",kwnames,&obj0)) goto fail;
9147 {
9148 arg1 = wxString_in_helper(obj0);
9149 if (arg1 == NULL) SWIG_fail;
9150 temp1 = true;
9151 }
9152 {
9153 PyThreadState* __tstate = wxPyBeginAllowThreads();
9154 wxLog::AddTraceMask((wxString const &)*arg1);
9155
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 Py_INCREF(Py_None); resultobj = Py_None;
9160 {
9161 if (temp1)
9162 delete arg1;
9163 }
9164 return resultobj;
9165 fail:
9166 {
9167 if (temp1)
9168 delete arg1;
9169 }
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_Log_RemoveTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj;
9176 wxString *arg1 = 0 ;
9177 bool temp1 = false ;
9178 PyObject * obj0 = 0 ;
9179 char *kwnames[] = {
9180 (char *) "str", NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_RemoveTraceMask",kwnames,&obj0)) goto fail;
9184 {
9185 arg1 = wxString_in_helper(obj0);
9186 if (arg1 == NULL) SWIG_fail;
9187 temp1 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 wxLog::RemoveTraceMask((wxString const &)*arg1);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 Py_INCREF(Py_None); resultobj = Py_None;
9197 {
9198 if (temp1)
9199 delete arg1;
9200 }
9201 return resultobj;
9202 fail:
9203 {
9204 if (temp1)
9205 delete arg1;
9206 }
9207 return NULL;
9208 }
9209
9210
9211 static PyObject *_wrap_Log_ClearTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9212 PyObject *resultobj;
9213 char *kwnames[] = {
9214 NULL
9215 };
9216
9217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_ClearTraceMasks",kwnames)) goto fail;
9218 {
9219 PyThreadState* __tstate = wxPyBeginAllowThreads();
9220 wxLog::ClearTraceMasks();
9221
9222 wxPyEndAllowThreads(__tstate);
9223 if (PyErr_Occurred()) SWIG_fail;
9224 }
9225 Py_INCREF(Py_None); resultobj = Py_None;
9226 return resultobj;
9227 fail:
9228 return NULL;
9229 }
9230
9231
9232 static PyObject *_wrap_Log_GetTraceMasks(PyObject *, PyObject *args, PyObject *kwargs) {
9233 PyObject *resultobj;
9234 wxArrayString *result;
9235 char *kwnames[] = {
9236 NULL
9237 };
9238
9239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMasks",kwnames)) goto fail;
9240 {
9241 PyThreadState* __tstate = wxPyBeginAllowThreads();
9242 {
9243 wxArrayString const &_result_ref = wxLog::GetTraceMasks();
9244 result = (wxArrayString *) &_result_ref;
9245 }
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxArrayString2PyList_helper(*result);
9252 }
9253 return resultobj;
9254 fail:
9255 return NULL;
9256 }
9257
9258
9259 static PyObject *_wrap_Log_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9260 PyObject *resultobj;
9261 wxChar *arg1 = (wxChar *) 0 ;
9262 PyObject * obj0 = 0 ;
9263 char *kwnames[] = {
9264 (char *) "ts", NULL
9265 };
9266
9267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_SetTimestamp",kwnames,&obj0)) goto fail;
9268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9269 if (SWIG_arg_fail(1)) SWIG_fail;
9270 {
9271 PyThreadState* __tstate = wxPyBeginAllowThreads();
9272 wxLog::SetTimestamp((wxChar const *)arg1);
9273
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 Py_INCREF(Py_None); resultobj = Py_None;
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 static PyObject *_wrap_Log_GetVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj;
9286 bool result;
9287 char *kwnames[] = {
9288 NULL
9289 };
9290
9291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetVerbose",kwnames)) goto fail;
9292 {
9293 PyThreadState* __tstate = wxPyBeginAllowThreads();
9294 result = (bool)wxLog::GetVerbose();
9295
9296 wxPyEndAllowThreads(__tstate);
9297 if (PyErr_Occurred()) SWIG_fail;
9298 }
9299 {
9300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9301 }
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_Log_GetTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj;
9310 wxTraceMask result;
9311 char *kwnames[] = {
9312 NULL
9313 };
9314
9315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTraceMask",kwnames)) goto fail;
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (wxTraceMask)wxLog::GetTraceMask();
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9325 }
9326 return resultobj;
9327 fail:
9328 return NULL;
9329 }
9330
9331
9332 static PyObject *_wrap_Log_IsAllowedTraceMask(PyObject *, PyObject *args, PyObject *kwargs) {
9333 PyObject *resultobj;
9334 wxChar *arg1 = (wxChar *) 0 ;
9335 bool result;
9336 PyObject * obj0 = 0 ;
9337 char *kwnames[] = {
9338 (char *) "mask", NULL
9339 };
9340
9341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_IsAllowedTraceMask",kwnames,&obj0)) goto fail;
9342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChar, SWIG_POINTER_EXCEPTION | 0);
9343 if (SWIG_arg_fail(1)) SWIG_fail;
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (bool)wxLog::IsAllowedTraceMask((wxChar const *)arg1);
9347
9348 wxPyEndAllowThreads(__tstate);
9349 if (PyErr_Occurred()) SWIG_fail;
9350 }
9351 {
9352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9353 }
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 static PyObject *_wrap_Log_GetLogLevel(PyObject *, PyObject *args, PyObject *kwargs) {
9361 PyObject *resultobj;
9362 wxLogLevel result;
9363 char *kwnames[] = {
9364 NULL
9365 };
9366
9367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetLogLevel",kwnames)) goto fail;
9368 {
9369 PyThreadState* __tstate = wxPyBeginAllowThreads();
9370 result = (wxLogLevel)wxLog::GetLogLevel();
9371
9372 wxPyEndAllowThreads(__tstate);
9373 if (PyErr_Occurred()) SWIG_fail;
9374 }
9375 {
9376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9377 }
9378 return resultobj;
9379 fail:
9380 return NULL;
9381 }
9382
9383
9384 static PyObject *_wrap_Log_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
9385 PyObject *resultobj;
9386 wxChar *result;
9387 char *kwnames[] = {
9388 NULL
9389 };
9390
9391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_GetTimestamp",kwnames)) goto fail;
9392 {
9393 PyThreadState* __tstate = wxPyBeginAllowThreads();
9394 result = (wxChar *)wxLog::GetTimestamp();
9395
9396 wxPyEndAllowThreads(__tstate);
9397 if (PyErr_Occurred()) SWIG_fail;
9398 }
9399 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChar, 0);
9400 return resultobj;
9401 fail:
9402 return NULL;
9403 }
9404
9405
9406 static PyObject *_wrap_Log_TimeStamp(PyObject *, PyObject *args, PyObject *kwargs) {
9407 PyObject *resultobj;
9408 wxString result;
9409 char *kwnames[] = {
9410 NULL
9411 };
9412
9413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Log_TimeStamp",kwnames)) goto fail;
9414 {
9415 PyThreadState* __tstate = wxPyBeginAllowThreads();
9416 result = Log_TimeStamp();
9417
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 {
9422 #if wxUSE_UNICODE
9423 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9424 #else
9425 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9426 #endif
9427 }
9428 return resultobj;
9429 fail:
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_Log_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxLog *arg1 = (wxLog *) 0 ;
9437 PyObject * obj0 = 0 ;
9438 char *kwnames[] = {
9439 (char *) "self", NULL
9440 };
9441
9442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Log_Destroy",kwnames,&obj0)) goto fail;
9443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9444 if (SWIG_arg_fail(1)) SWIG_fail;
9445 {
9446 PyThreadState* __tstate = wxPyBeginAllowThreads();
9447 wxLog_Destroy(arg1);
9448
9449 wxPyEndAllowThreads(__tstate);
9450 if (PyErr_Occurred()) SWIG_fail;
9451 }
9452 Py_INCREF(Py_None); resultobj = Py_None;
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 static PyObject * Log_swigregister(PyObject *, PyObject *args) {
9460 PyObject *obj;
9461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9462 SWIG_TypeClientData(SWIGTYPE_p_wxLog, obj);
9463 Py_INCREF(obj);
9464 return Py_BuildValue((char *)"");
9465 }
9466 static PyObject *_wrap_new_LogStderr(PyObject *, PyObject *args, PyObject *kwargs) {
9467 PyObject *resultobj;
9468 wxLogStderr *result;
9469 char *kwnames[] = {
9470 NULL
9471 };
9472
9473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogStderr",kwnames)) goto fail;
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (wxLogStderr *)new wxLogStderr();
9477
9478 wxPyEndAllowThreads(__tstate);
9479 if (PyErr_Occurred()) SWIG_fail;
9480 }
9481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogStderr, 1);
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 static PyObject * LogStderr_swigregister(PyObject *, PyObject *args) {
9489 PyObject *obj;
9490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9491 SWIG_TypeClientData(SWIGTYPE_p_wxLogStderr, obj);
9492 Py_INCREF(obj);
9493 return Py_BuildValue((char *)"");
9494 }
9495 static PyObject *_wrap_new_LogTextCtrl(PyObject *, PyObject *args, PyObject *kwargs) {
9496 PyObject *resultobj;
9497 wxTextCtrl *arg1 = (wxTextCtrl *) 0 ;
9498 wxLogTextCtrl *result;
9499 PyObject * obj0 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "pTextCtrl", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogTextCtrl",kwnames,&obj0)) goto fail;
9505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextCtrl, SWIG_POINTER_EXCEPTION | 0);
9506 if (SWIG_arg_fail(1)) SWIG_fail;
9507 {
9508 PyThreadState* __tstate = wxPyBeginAllowThreads();
9509 result = (wxLogTextCtrl *)new wxLogTextCtrl(arg1);
9510
9511 wxPyEndAllowThreads(__tstate);
9512 if (PyErr_Occurred()) SWIG_fail;
9513 }
9514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogTextCtrl, 1);
9515 return resultobj;
9516 fail:
9517 return NULL;
9518 }
9519
9520
9521 static PyObject * LogTextCtrl_swigregister(PyObject *, PyObject *args) {
9522 PyObject *obj;
9523 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9524 SWIG_TypeClientData(SWIGTYPE_p_wxLogTextCtrl, obj);
9525 Py_INCREF(obj);
9526 return Py_BuildValue((char *)"");
9527 }
9528 static PyObject *_wrap_new_LogGui(PyObject *, PyObject *args, PyObject *kwargs) {
9529 PyObject *resultobj;
9530 wxLogGui *result;
9531 char *kwnames[] = {
9532 NULL
9533 };
9534
9535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogGui",kwnames)) goto fail;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 result = (wxLogGui *)new wxLogGui();
9539
9540 wxPyEndAllowThreads(__tstate);
9541 if (PyErr_Occurred()) SWIG_fail;
9542 }
9543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogGui, 1);
9544 return resultobj;
9545 fail:
9546 return NULL;
9547 }
9548
9549
9550 static PyObject * LogGui_swigregister(PyObject *, PyObject *args) {
9551 PyObject *obj;
9552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9553 SWIG_TypeClientData(SWIGTYPE_p_wxLogGui, obj);
9554 Py_INCREF(obj);
9555 return Py_BuildValue((char *)"");
9556 }
9557 static PyObject *_wrap_new_LogWindow(PyObject *, PyObject *args, PyObject *kwargs) {
9558 PyObject *resultobj;
9559 wxFrame *arg1 = (wxFrame *) 0 ;
9560 wxString *arg2 = 0 ;
9561 bool arg3 = (bool) true ;
9562 bool arg4 = (bool) true ;
9563 wxLogWindow *result;
9564 bool temp2 = false ;
9565 PyObject * obj0 = 0 ;
9566 PyObject * obj1 = 0 ;
9567 PyObject * obj2 = 0 ;
9568 PyObject * obj3 = 0 ;
9569 char *kwnames[] = {
9570 (char *) "pParent",(char *) "szTitle",(char *) "bShow",(char *) "bPassToOld", NULL
9571 };
9572
9573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:new_LogWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
9574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
9575 if (SWIG_arg_fail(1)) SWIG_fail;
9576 {
9577 arg2 = wxString_in_helper(obj1);
9578 if (arg2 == NULL) SWIG_fail;
9579 temp2 = true;
9580 }
9581 if (obj2) {
9582 {
9583 arg3 = (bool)(SWIG_As_bool(obj2));
9584 if (SWIG_arg_fail(3)) SWIG_fail;
9585 }
9586 }
9587 if (obj3) {
9588 {
9589 arg4 = (bool)(SWIG_As_bool(obj3));
9590 if (SWIG_arg_fail(4)) SWIG_fail;
9591 }
9592 }
9593 {
9594 PyThreadState* __tstate = wxPyBeginAllowThreads();
9595 result = (wxLogWindow *)new wxLogWindow(arg1,(wxString const &)*arg2,arg3,arg4);
9596
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogWindow, 1);
9601 {
9602 if (temp2)
9603 delete arg2;
9604 }
9605 return resultobj;
9606 fail:
9607 {
9608 if (temp2)
9609 delete arg2;
9610 }
9611 return NULL;
9612 }
9613
9614
9615 static PyObject *_wrap_LogWindow_Show(PyObject *, PyObject *args, PyObject *kwargs) {
9616 PyObject *resultobj;
9617 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9618 bool arg2 = (bool) true ;
9619 PyObject * obj0 = 0 ;
9620 PyObject * obj1 = 0 ;
9621 char *kwnames[] = {
9622 (char *) "self",(char *) "bShow", NULL
9623 };
9624
9625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:LogWindow_Show",kwnames,&obj0,&obj1)) goto fail;
9626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9627 if (SWIG_arg_fail(1)) SWIG_fail;
9628 if (obj1) {
9629 {
9630 arg2 = (bool)(SWIG_As_bool(obj1));
9631 if (SWIG_arg_fail(2)) SWIG_fail;
9632 }
9633 }
9634 {
9635 PyThreadState* __tstate = wxPyBeginAllowThreads();
9636 (arg1)->Show(arg2);
9637
9638 wxPyEndAllowThreads(__tstate);
9639 if (PyErr_Occurred()) SWIG_fail;
9640 }
9641 Py_INCREF(Py_None); resultobj = Py_None;
9642 return resultobj;
9643 fail:
9644 return NULL;
9645 }
9646
9647
9648 static PyObject *_wrap_LogWindow_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
9649 PyObject *resultobj;
9650 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9651 wxFrame *result;
9652 PyObject * obj0 = 0 ;
9653 char *kwnames[] = {
9654 (char *) "self", NULL
9655 };
9656
9657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetFrame",kwnames,&obj0)) goto fail;
9658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9659 if (SWIG_arg_fail(1)) SWIG_fail;
9660 {
9661 PyThreadState* __tstate = wxPyBeginAllowThreads();
9662 result = (wxFrame *)((wxLogWindow const *)arg1)->GetFrame();
9663
9664 wxPyEndAllowThreads(__tstate);
9665 if (PyErr_Occurred()) SWIG_fail;
9666 }
9667 {
9668 resultobj = wxPyMake_wxObject(result, 0);
9669 }
9670 return resultobj;
9671 fail:
9672 return NULL;
9673 }
9674
9675
9676 static PyObject *_wrap_LogWindow_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9677 PyObject *resultobj;
9678 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9679 wxLog *result;
9680 PyObject * obj0 = 0 ;
9681 char *kwnames[] = {
9682 (char *) "self", NULL
9683 };
9684
9685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_GetOldLog",kwnames,&obj0)) goto fail;
9686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9687 if (SWIG_arg_fail(1)) SWIG_fail;
9688 {
9689 PyThreadState* __tstate = wxPyBeginAllowThreads();
9690 result = (wxLog *)((wxLogWindow const *)arg1)->GetOldLog();
9691
9692 wxPyEndAllowThreads(__tstate);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 static PyObject *_wrap_LogWindow_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj;
9704 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9705 bool result;
9706 PyObject * obj0 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "self", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWindow_IsPassingMessages",kwnames,&obj0)) goto fail;
9712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9713 if (SWIG_arg_fail(1)) SWIG_fail;
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)((wxLogWindow const *)arg1)->IsPassingMessages();
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 return resultobj;
9725 fail:
9726 return NULL;
9727 }
9728
9729
9730 static PyObject *_wrap_LogWindow_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9731 PyObject *resultobj;
9732 wxLogWindow *arg1 = (wxLogWindow *) 0 ;
9733 bool arg2 ;
9734 PyObject * obj0 = 0 ;
9735 PyObject * obj1 = 0 ;
9736 char *kwnames[] = {
9737 (char *) "self",(char *) "bDoPass", NULL
9738 };
9739
9740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogWindow_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogWindow, SWIG_POINTER_EXCEPTION | 0);
9742 if (SWIG_arg_fail(1)) SWIG_fail;
9743 {
9744 arg2 = (bool)(SWIG_As_bool(obj1));
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 {
9748 PyThreadState* __tstate = wxPyBeginAllowThreads();
9749 (arg1)->PassMessages(arg2);
9750
9751 wxPyEndAllowThreads(__tstate);
9752 if (PyErr_Occurred()) SWIG_fail;
9753 }
9754 Py_INCREF(Py_None); resultobj = Py_None;
9755 return resultobj;
9756 fail:
9757 return NULL;
9758 }
9759
9760
9761 static PyObject * LogWindow_swigregister(PyObject *, PyObject *args) {
9762 PyObject *obj;
9763 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9764 SWIG_TypeClientData(SWIGTYPE_p_wxLogWindow, obj);
9765 Py_INCREF(obj);
9766 return Py_BuildValue((char *)"");
9767 }
9768 static PyObject *_wrap_new_LogChain(PyObject *, PyObject *args, PyObject *kwargs) {
9769 PyObject *resultobj;
9770 wxLog *arg1 = (wxLog *) 0 ;
9771 wxLogChain *result;
9772 PyObject * obj0 = 0 ;
9773 char *kwnames[] = {
9774 (char *) "logger", NULL
9775 };
9776
9777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_LogChain",kwnames,&obj0)) goto fail;
9778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9779 if (SWIG_arg_fail(1)) SWIG_fail;
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 result = (wxLogChain *)new wxLogChain(arg1);
9783
9784 wxPyEndAllowThreads(__tstate);
9785 if (PyErr_Occurred()) SWIG_fail;
9786 }
9787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogChain, 1);
9788 return resultobj;
9789 fail:
9790 return NULL;
9791 }
9792
9793
9794 static PyObject *_wrap_LogChain_SetLog(PyObject *, PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj;
9796 wxLogChain *arg1 = (wxLogChain *) 0 ;
9797 wxLog *arg2 = (wxLog *) 0 ;
9798 PyObject * obj0 = 0 ;
9799 PyObject * obj1 = 0 ;
9800 char *kwnames[] = {
9801 (char *) "self",(char *) "logger", NULL
9802 };
9803
9804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_SetLog",kwnames,&obj0,&obj1)) goto fail;
9805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9806 if (SWIG_arg_fail(1)) SWIG_fail;
9807 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLog, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(2)) SWIG_fail;
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 (arg1)->SetLog(arg2);
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 Py_INCREF(Py_None); resultobj = Py_None;
9817 return resultobj;
9818 fail:
9819 return NULL;
9820 }
9821
9822
9823 static PyObject *_wrap_LogChain_PassMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9824 PyObject *resultobj;
9825 wxLogChain *arg1 = (wxLogChain *) 0 ;
9826 bool arg2 ;
9827 PyObject * obj0 = 0 ;
9828 PyObject * obj1 = 0 ;
9829 char *kwnames[] = {
9830 (char *) "self",(char *) "bDoPass", NULL
9831 };
9832
9833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogChain_PassMessages",kwnames,&obj0,&obj1)) goto fail;
9834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9835 if (SWIG_arg_fail(1)) SWIG_fail;
9836 {
9837 arg2 = (bool)(SWIG_As_bool(obj1));
9838 if (SWIG_arg_fail(2)) SWIG_fail;
9839 }
9840 {
9841 PyThreadState* __tstate = wxPyBeginAllowThreads();
9842 (arg1)->PassMessages(arg2);
9843
9844 wxPyEndAllowThreads(__tstate);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 Py_INCREF(Py_None); resultobj = Py_None;
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 static PyObject *_wrap_LogChain_IsPassingMessages(PyObject *, PyObject *args, PyObject *kwargs) {
9855 PyObject *resultobj;
9856 wxLogChain *arg1 = (wxLogChain *) 0 ;
9857 bool result;
9858 PyObject * obj0 = 0 ;
9859 char *kwnames[] = {
9860 (char *) "self", NULL
9861 };
9862
9863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_IsPassingMessages",kwnames,&obj0)) goto fail;
9864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9865 if (SWIG_arg_fail(1)) SWIG_fail;
9866 {
9867 PyThreadState* __tstate = wxPyBeginAllowThreads();
9868 result = (bool)(arg1)->IsPassingMessages();
9869
9870 wxPyEndAllowThreads(__tstate);
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 {
9874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9875 }
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject *_wrap_LogChain_GetOldLog(PyObject *, PyObject *args, PyObject *kwargs) {
9883 PyObject *resultobj;
9884 wxLogChain *arg1 = (wxLogChain *) 0 ;
9885 wxLog *result;
9886 PyObject * obj0 = 0 ;
9887 char *kwnames[] = {
9888 (char *) "self", NULL
9889 };
9890
9891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogChain_GetOldLog",kwnames,&obj0)) goto fail;
9892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogChain, SWIG_POINTER_EXCEPTION | 0);
9893 if (SWIG_arg_fail(1)) SWIG_fail;
9894 {
9895 PyThreadState* __tstate = wxPyBeginAllowThreads();
9896 result = (wxLog *)(arg1)->GetOldLog();
9897
9898 wxPyEndAllowThreads(__tstate);
9899 if (PyErr_Occurred()) SWIG_fail;
9900 }
9901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLog, 0);
9902 return resultobj;
9903 fail:
9904 return NULL;
9905 }
9906
9907
9908 static PyObject * LogChain_swigregister(PyObject *, PyObject *args) {
9909 PyObject *obj;
9910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9911 SWIG_TypeClientData(SWIGTYPE_p_wxLogChain, obj);
9912 Py_INCREF(obj);
9913 return Py_BuildValue((char *)"");
9914 }
9915 static PyObject *_wrap_SysErrorCode(PyObject *, PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj;
9917 unsigned long result;
9918 char *kwnames[] = {
9919 NULL
9920 };
9921
9922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":SysErrorCode",kwnames)) goto fail;
9923 {
9924 PyThreadState* __tstate = wxPyBeginAllowThreads();
9925 result = (unsigned long)wxSysErrorCode();
9926
9927 wxPyEndAllowThreads(__tstate);
9928 if (PyErr_Occurred()) SWIG_fail;
9929 }
9930 {
9931 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
9932 }
9933 return resultobj;
9934 fail:
9935 return NULL;
9936 }
9937
9938
9939 static PyObject *_wrap_SysErrorMsg(PyObject *, PyObject *args, PyObject *kwargs) {
9940 PyObject *resultobj;
9941 unsigned long arg1 = (unsigned long) 0 ;
9942 wxString result;
9943 PyObject * obj0 = 0 ;
9944 char *kwnames[] = {
9945 (char *) "nErrCode", NULL
9946 };
9947
9948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:SysErrorMsg",kwnames,&obj0)) goto fail;
9949 if (obj0) {
9950 {
9951 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
9952 if (SWIG_arg_fail(1)) SWIG_fail;
9953 }
9954 }
9955 {
9956 PyThreadState* __tstate = wxPyBeginAllowThreads();
9957 result = wxSysErrorMsg(arg1);
9958
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 static PyObject *_wrap_LogFatalError(PyObject *, PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj;
9977 wxString *arg1 = 0 ;
9978 bool temp1 = false ;
9979 PyObject * obj0 = 0 ;
9980 char *kwnames[] = {
9981 (char *) "msg", NULL
9982 };
9983
9984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogFatalError",kwnames,&obj0)) goto fail;
9985 {
9986 arg1 = wxString_in_helper(obj0);
9987 if (arg1 == NULL) SWIG_fail;
9988 temp1 = true;
9989 }
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 wxPyLogFatalError((wxString const &)*arg1);
9993
9994 wxPyEndAllowThreads(__tstate);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 Py_INCREF(Py_None); resultobj = Py_None;
9998 {
9999 if (temp1)
10000 delete arg1;
10001 }
10002 return resultobj;
10003 fail:
10004 {
10005 if (temp1)
10006 delete arg1;
10007 }
10008 return NULL;
10009 }
10010
10011
10012 static PyObject *_wrap_LogError(PyObject *, PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj;
10014 wxString *arg1 = 0 ;
10015 bool temp1 = false ;
10016 PyObject * obj0 = 0 ;
10017 char *kwnames[] = {
10018 (char *) "msg", NULL
10019 };
10020
10021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogError",kwnames,&obj0)) goto fail;
10022 {
10023 arg1 = wxString_in_helper(obj0);
10024 if (arg1 == NULL) SWIG_fail;
10025 temp1 = true;
10026 }
10027 {
10028 PyThreadState* __tstate = wxPyBeginAllowThreads();
10029 wxPyLogError((wxString const &)*arg1);
10030
10031 wxPyEndAllowThreads(__tstate);
10032 if (PyErr_Occurred()) SWIG_fail;
10033 }
10034 Py_INCREF(Py_None); resultobj = Py_None;
10035 {
10036 if (temp1)
10037 delete arg1;
10038 }
10039 return resultobj;
10040 fail:
10041 {
10042 if (temp1)
10043 delete arg1;
10044 }
10045 return NULL;
10046 }
10047
10048
10049 static PyObject *_wrap_LogWarning(PyObject *, PyObject *args, PyObject *kwargs) {
10050 PyObject *resultobj;
10051 wxString *arg1 = 0 ;
10052 bool temp1 = false ;
10053 PyObject * obj0 = 0 ;
10054 char *kwnames[] = {
10055 (char *) "msg", NULL
10056 };
10057
10058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogWarning",kwnames,&obj0)) goto fail;
10059 {
10060 arg1 = wxString_in_helper(obj0);
10061 if (arg1 == NULL) SWIG_fail;
10062 temp1 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 wxPyLogWarning((wxString const &)*arg1);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp1)
10074 delete arg1;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp1)
10080 delete arg1;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_LogMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxString *arg1 = 0 ;
10089 bool temp1 = false ;
10090 PyObject * obj0 = 0 ;
10091 char *kwnames[] = {
10092 (char *) "msg", NULL
10093 };
10094
10095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogMessage",kwnames,&obj0)) goto fail;
10096 {
10097 arg1 = wxString_in_helper(obj0);
10098 if (arg1 == NULL) SWIG_fail;
10099 temp1 = true;
10100 }
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 wxPyLogMessage((wxString const &)*arg1);
10104
10105 wxPyEndAllowThreads(__tstate);
10106 if (PyErr_Occurred()) SWIG_fail;
10107 }
10108 Py_INCREF(Py_None); resultobj = Py_None;
10109 {
10110 if (temp1)
10111 delete arg1;
10112 }
10113 return resultobj;
10114 fail:
10115 {
10116 if (temp1)
10117 delete arg1;
10118 }
10119 return NULL;
10120 }
10121
10122
10123 static PyObject *_wrap_LogInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10124 PyObject *resultobj;
10125 wxString *arg1 = 0 ;
10126 bool temp1 = false ;
10127 PyObject * obj0 = 0 ;
10128 char *kwnames[] = {
10129 (char *) "msg", NULL
10130 };
10131
10132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogInfo",kwnames,&obj0)) goto fail;
10133 {
10134 arg1 = wxString_in_helper(obj0);
10135 if (arg1 == NULL) SWIG_fail;
10136 temp1 = true;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 wxPyLogInfo((wxString const &)*arg1);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 {
10147 if (temp1)
10148 delete arg1;
10149 }
10150 return resultobj;
10151 fail:
10152 {
10153 if (temp1)
10154 delete arg1;
10155 }
10156 return NULL;
10157 }
10158
10159
10160 static PyObject *_wrap_LogDebug(PyObject *, PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj;
10162 wxString *arg1 = 0 ;
10163 bool temp1 = false ;
10164 PyObject * obj0 = 0 ;
10165 char *kwnames[] = {
10166 (char *) "msg", NULL
10167 };
10168
10169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogDebug",kwnames,&obj0)) goto fail;
10170 {
10171 arg1 = wxString_in_helper(obj0);
10172 if (arg1 == NULL) SWIG_fail;
10173 temp1 = true;
10174 }
10175 {
10176 PyThreadState* __tstate = wxPyBeginAllowThreads();
10177 wxPyLogDebug((wxString const &)*arg1);
10178
10179 wxPyEndAllowThreads(__tstate);
10180 if (PyErr_Occurred()) SWIG_fail;
10181 }
10182 Py_INCREF(Py_None); resultobj = Py_None;
10183 {
10184 if (temp1)
10185 delete arg1;
10186 }
10187 return resultobj;
10188 fail:
10189 {
10190 if (temp1)
10191 delete arg1;
10192 }
10193 return NULL;
10194 }
10195
10196
10197 static PyObject *_wrap_LogVerbose(PyObject *, PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj;
10199 wxString *arg1 = 0 ;
10200 bool temp1 = false ;
10201 PyObject * obj0 = 0 ;
10202 char *kwnames[] = {
10203 (char *) "msg", NULL
10204 };
10205
10206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogVerbose",kwnames,&obj0)) goto fail;
10207 {
10208 arg1 = wxString_in_helper(obj0);
10209 if (arg1 == NULL) SWIG_fail;
10210 temp1 = true;
10211 }
10212 {
10213 PyThreadState* __tstate = wxPyBeginAllowThreads();
10214 wxPyLogVerbose((wxString const &)*arg1);
10215
10216 wxPyEndAllowThreads(__tstate);
10217 if (PyErr_Occurred()) SWIG_fail;
10218 }
10219 Py_INCREF(Py_None); resultobj = Py_None;
10220 {
10221 if (temp1)
10222 delete arg1;
10223 }
10224 return resultobj;
10225 fail:
10226 {
10227 if (temp1)
10228 delete arg1;
10229 }
10230 return NULL;
10231 }
10232
10233
10234 static PyObject *_wrap_LogStatus(PyObject *, PyObject *args, PyObject *kwargs) {
10235 PyObject *resultobj;
10236 wxString *arg1 = 0 ;
10237 bool temp1 = false ;
10238 PyObject * obj0 = 0 ;
10239 char *kwnames[] = {
10240 (char *) "msg", NULL
10241 };
10242
10243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogStatus",kwnames,&obj0)) goto fail;
10244 {
10245 arg1 = wxString_in_helper(obj0);
10246 if (arg1 == NULL) SWIG_fail;
10247 temp1 = true;
10248 }
10249 {
10250 PyThreadState* __tstate = wxPyBeginAllowThreads();
10251 wxPyLogStatus((wxString const &)*arg1);
10252
10253 wxPyEndAllowThreads(__tstate);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 Py_INCREF(Py_None); resultobj = Py_None;
10257 {
10258 if (temp1)
10259 delete arg1;
10260 }
10261 return resultobj;
10262 fail:
10263 {
10264 if (temp1)
10265 delete arg1;
10266 }
10267 return NULL;
10268 }
10269
10270
10271 static PyObject *_wrap_LogStatusFrame(PyObject *, PyObject *args, PyObject *kwargs) {
10272 PyObject *resultobj;
10273 wxFrame *arg1 = (wxFrame *) 0 ;
10274 wxString *arg2 = 0 ;
10275 bool temp2 = false ;
10276 PyObject * obj0 = 0 ;
10277 PyObject * obj1 = 0 ;
10278 char *kwnames[] = {
10279 (char *) "pFrame",(char *) "msg", NULL
10280 };
10281
10282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogStatusFrame",kwnames,&obj0,&obj1)) goto fail;
10283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
10284 if (SWIG_arg_fail(1)) SWIG_fail;
10285 {
10286 arg2 = wxString_in_helper(obj1);
10287 if (arg2 == NULL) SWIG_fail;
10288 temp2 = true;
10289 }
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 wxPyLogStatusFrame(arg1,(wxString const &)*arg2);
10293
10294 wxPyEndAllowThreads(__tstate);
10295 if (PyErr_Occurred()) SWIG_fail;
10296 }
10297 Py_INCREF(Py_None); resultobj = Py_None;
10298 {
10299 if (temp2)
10300 delete arg2;
10301 }
10302 return resultobj;
10303 fail:
10304 {
10305 if (temp2)
10306 delete arg2;
10307 }
10308 return NULL;
10309 }
10310
10311
10312 static PyObject *_wrap_LogSysError(PyObject *, PyObject *args, PyObject *kwargs) {
10313 PyObject *resultobj;
10314 wxString *arg1 = 0 ;
10315 bool temp1 = false ;
10316 PyObject * obj0 = 0 ;
10317 char *kwnames[] = {
10318 (char *) "msg", NULL
10319 };
10320
10321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LogSysError",kwnames,&obj0)) goto fail;
10322 {
10323 arg1 = wxString_in_helper(obj0);
10324 if (arg1 == NULL) SWIG_fail;
10325 temp1 = true;
10326 }
10327 {
10328 PyThreadState* __tstate = wxPyBeginAllowThreads();
10329 wxPyLogSysError((wxString const &)*arg1);
10330
10331 wxPyEndAllowThreads(__tstate);
10332 if (PyErr_Occurred()) SWIG_fail;
10333 }
10334 Py_INCREF(Py_None); resultobj = Py_None;
10335 {
10336 if (temp1)
10337 delete arg1;
10338 }
10339 return resultobj;
10340 fail:
10341 {
10342 if (temp1)
10343 delete arg1;
10344 }
10345 return NULL;
10346 }
10347
10348
10349 static PyObject *_wrap_LogGeneric(PyObject *, PyObject *args, PyObject *kwargs) {
10350 PyObject *resultobj;
10351 unsigned long arg1 ;
10352 wxString *arg2 = 0 ;
10353 bool temp2 = false ;
10354 PyObject * obj0 = 0 ;
10355 PyObject * obj1 = 0 ;
10356 char *kwnames[] = {
10357 (char *) "level",(char *) "msg", NULL
10358 };
10359
10360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LogGeneric",kwnames,&obj0,&obj1)) goto fail;
10361 {
10362 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 }
10365 {
10366 arg2 = wxString_in_helper(obj1);
10367 if (arg2 == NULL) SWIG_fail;
10368 temp2 = true;
10369 }
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 wxPyLogGeneric(arg1,(wxString const &)*arg2);
10373
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 Py_INCREF(Py_None); resultobj = Py_None;
10378 {
10379 if (temp2)
10380 delete arg2;
10381 }
10382 return resultobj;
10383 fail:
10384 {
10385 if (temp2)
10386 delete arg2;
10387 }
10388 return NULL;
10389 }
10390
10391
10392 static PyObject *_wrap_LogTrace__SWIG_0(PyObject *, PyObject *args) {
10393 PyObject *resultobj;
10394 unsigned long arg1 ;
10395 wxString *arg2 = 0 ;
10396 bool temp2 = false ;
10397 PyObject * obj0 = 0 ;
10398 PyObject * obj1 = 0 ;
10399
10400 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10401 {
10402 arg1 = (unsigned long)(SWIG_As_unsigned_SS_long(obj0));
10403 if (SWIG_arg_fail(1)) SWIG_fail;
10404 }
10405 {
10406 arg2 = wxString_in_helper(obj1);
10407 if (arg2 == NULL) SWIG_fail;
10408 temp2 = true;
10409 }
10410 {
10411 PyThreadState* __tstate = wxPyBeginAllowThreads();
10412 wxPyLogTrace(arg1,(wxString const &)*arg2);
10413
10414 wxPyEndAllowThreads(__tstate);
10415 if (PyErr_Occurred()) SWIG_fail;
10416 }
10417 Py_INCREF(Py_None); resultobj = Py_None;
10418 {
10419 if (temp2)
10420 delete arg2;
10421 }
10422 return resultobj;
10423 fail:
10424 {
10425 if (temp2)
10426 delete arg2;
10427 }
10428 return NULL;
10429 }
10430
10431
10432 static PyObject *_wrap_LogTrace__SWIG_1(PyObject *, PyObject *args) {
10433 PyObject *resultobj;
10434 wxString *arg1 = 0 ;
10435 wxString *arg2 = 0 ;
10436 bool temp1 = false ;
10437 bool temp2 = false ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440
10441 if(!PyArg_ParseTuple(args,(char *)"OO:LogTrace",&obj0,&obj1)) goto fail;
10442 {
10443 arg1 = wxString_in_helper(obj0);
10444 if (arg1 == NULL) SWIG_fail;
10445 temp1 = true;
10446 }
10447 {
10448 arg2 = wxString_in_helper(obj1);
10449 if (arg2 == NULL) SWIG_fail;
10450 temp2 = true;
10451 }
10452 {
10453 PyThreadState* __tstate = wxPyBeginAllowThreads();
10454 wxPyLogTrace((wxString const &)*arg1,(wxString const &)*arg2);
10455
10456 wxPyEndAllowThreads(__tstate);
10457 if (PyErr_Occurred()) SWIG_fail;
10458 }
10459 Py_INCREF(Py_None); resultobj = Py_None;
10460 {
10461 if (temp1)
10462 delete arg1;
10463 }
10464 {
10465 if (temp2)
10466 delete arg2;
10467 }
10468 return resultobj;
10469 fail:
10470 {
10471 if (temp1)
10472 delete arg1;
10473 }
10474 {
10475 if (temp2)
10476 delete arg2;
10477 }
10478 return NULL;
10479 }
10480
10481
10482 static PyObject *_wrap_LogTrace(PyObject *self, PyObject *args) {
10483 int argc;
10484 PyObject *argv[3];
10485 int ii;
10486
10487 argc = PyObject_Length(args);
10488 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
10489 argv[ii] = PyTuple_GetItem(args,ii);
10490 }
10491 if (argc == 2) {
10492 int _v;
10493 {
10494 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
10495 }
10496 if (_v) {
10497 {
10498 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10499 }
10500 if (_v) {
10501 return _wrap_LogTrace__SWIG_1(self,args);
10502 }
10503 }
10504 }
10505 if (argc == 2) {
10506 int _v;
10507 _v = SWIG_Check_unsigned_SS_long(argv[0]);
10508 if (_v) {
10509 {
10510 _v = PyString_Check(argv[1]) || PyUnicode_Check(argv[1]);
10511 }
10512 if (_v) {
10513 return _wrap_LogTrace__SWIG_0(self,args);
10514 }
10515 }
10516 }
10517
10518 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'LogTrace'");
10519 return NULL;
10520 }
10521
10522
10523 static PyObject *_wrap_SafeShowMessage(PyObject *, PyObject *args, PyObject *kwargs) {
10524 PyObject *resultobj;
10525 wxString *arg1 = 0 ;
10526 wxString *arg2 = 0 ;
10527 bool temp1 = false ;
10528 bool temp2 = false ;
10529 PyObject * obj0 = 0 ;
10530 PyObject * obj1 = 0 ;
10531 char *kwnames[] = {
10532 (char *) "title",(char *) "text", NULL
10533 };
10534
10535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SafeShowMessage",kwnames,&obj0,&obj1)) goto fail;
10536 {
10537 arg1 = wxString_in_helper(obj0);
10538 if (arg1 == NULL) SWIG_fail;
10539 temp1 = true;
10540 }
10541 {
10542 arg2 = wxString_in_helper(obj1);
10543 if (arg2 == NULL) SWIG_fail;
10544 temp2 = true;
10545 }
10546 {
10547 PyThreadState* __tstate = wxPyBeginAllowThreads();
10548 wxSafeShowMessage((wxString const &)*arg1,(wxString const &)*arg2);
10549
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 Py_INCREF(Py_None); resultobj = Py_None;
10554 {
10555 if (temp1)
10556 delete arg1;
10557 }
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return resultobj;
10563 fail:
10564 {
10565 if (temp1)
10566 delete arg1;
10567 }
10568 {
10569 if (temp2)
10570 delete arg2;
10571 }
10572 return NULL;
10573 }
10574
10575
10576 static PyObject *_wrap_new_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10577 PyObject *resultobj;
10578 wxLogNull *result;
10579 char *kwnames[] = {
10580 NULL
10581 };
10582
10583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LogNull",kwnames)) goto fail;
10584 {
10585 PyThreadState* __tstate = wxPyBeginAllowThreads();
10586 result = (wxLogNull *)new wxLogNull();
10587
10588 wxPyEndAllowThreads(__tstate);
10589 if (PyErr_Occurred()) SWIG_fail;
10590 }
10591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLogNull, 1);
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 static PyObject *_wrap_delete_LogNull(PyObject *, PyObject *args, PyObject *kwargs) {
10599 PyObject *resultobj;
10600 wxLogNull *arg1 = (wxLogNull *) 0 ;
10601 PyObject * obj0 = 0 ;
10602 char *kwnames[] = {
10603 (char *) "self", NULL
10604 };
10605
10606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_LogNull",kwnames,&obj0)) goto fail;
10607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLogNull, SWIG_POINTER_EXCEPTION | 0);
10608 if (SWIG_arg_fail(1)) SWIG_fail;
10609 {
10610 PyThreadState* __tstate = wxPyBeginAllowThreads();
10611 delete arg1;
10612
10613 wxPyEndAllowThreads(__tstate);
10614 if (PyErr_Occurred()) SWIG_fail;
10615 }
10616 Py_INCREF(Py_None); resultobj = Py_None;
10617 return resultobj;
10618 fail:
10619 return NULL;
10620 }
10621
10622
10623 static PyObject * LogNull_swigregister(PyObject *, PyObject *args) {
10624 PyObject *obj;
10625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10626 SWIG_TypeClientData(SWIGTYPE_p_wxLogNull, obj);
10627 Py_INCREF(obj);
10628 return Py_BuildValue((char *)"");
10629 }
10630 static PyObject *_wrap_new_PyLog(PyObject *, PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj;
10632 wxPyLog *result;
10633 char *kwnames[] = {
10634 NULL
10635 };
10636
10637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyLog",kwnames)) goto fail;
10638 {
10639 PyThreadState* __tstate = wxPyBeginAllowThreads();
10640 result = (wxPyLog *)new wxPyLog();
10641
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyLog, 1);
10646 return resultobj;
10647 fail:
10648 return NULL;
10649 }
10650
10651
10652 static PyObject *_wrap_PyLog__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10653 PyObject *resultobj;
10654 wxPyLog *arg1 = (wxPyLog *) 0 ;
10655 PyObject *arg2 = (PyObject *) 0 ;
10656 PyObject *arg3 = (PyObject *) 0 ;
10657 PyObject * obj0 = 0 ;
10658 PyObject * obj1 = 0 ;
10659 PyObject * obj2 = 0 ;
10660 char *kwnames[] = {
10661 (char *) "self",(char *) "self",(char *) "_class", NULL
10662 };
10663
10664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyLog__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyLog, SWIG_POINTER_EXCEPTION | 0);
10666 if (SWIG_arg_fail(1)) SWIG_fail;
10667 arg2 = obj1;
10668 arg3 = obj2;
10669 {
10670 PyThreadState* __tstate = wxPyBeginAllowThreads();
10671 (arg1)->_setCallbackInfo(arg2,arg3);
10672
10673 wxPyEndAllowThreads(__tstate);
10674 if (PyErr_Occurred()) SWIG_fail;
10675 }
10676 Py_INCREF(Py_None); resultobj = Py_None;
10677 return resultobj;
10678 fail:
10679 return NULL;
10680 }
10681
10682
10683 static PyObject * PyLog_swigregister(PyObject *, PyObject *args) {
10684 PyObject *obj;
10685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10686 SWIG_TypeClientData(SWIGTYPE_p_wxPyLog, obj);
10687 Py_INCREF(obj);
10688 return Py_BuildValue((char *)"");
10689 }
10690 static PyObject *_wrap_Process_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
10691 PyObject *resultobj;
10692 int arg1 ;
10693 wxSignal arg2 = (wxSignal) wxSIGTERM ;
10694 int arg3 = (int) wxKILL_NOCHILDREN ;
10695 wxKillError result;
10696 PyObject * obj0 = 0 ;
10697 PyObject * obj1 = 0 ;
10698 PyObject * obj2 = 0 ;
10699 char *kwnames[] = {
10700 (char *) "pid",(char *) "sig",(char *) "flags", NULL
10701 };
10702
10703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Process_Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
10704 {
10705 arg1 = (int)(SWIG_As_int(obj0));
10706 if (SWIG_arg_fail(1)) SWIG_fail;
10707 }
10708 if (obj1) {
10709 {
10710 arg2 = (wxSignal)(SWIG_As_int(obj1));
10711 if (SWIG_arg_fail(2)) SWIG_fail;
10712 }
10713 }
10714 if (obj2) {
10715 {
10716 arg3 = (int)(SWIG_As_int(obj2));
10717 if (SWIG_arg_fail(3)) SWIG_fail;
10718 }
10719 }
10720 {
10721 PyThreadState* __tstate = wxPyBeginAllowThreads();
10722 result = (wxKillError)wxPyProcess::Kill(arg1,(wxSignal )arg2,arg3);
10723
10724 wxPyEndAllowThreads(__tstate);
10725 if (PyErr_Occurred()) SWIG_fail;
10726 }
10727 resultobj = SWIG_From_int((result));
10728 return resultobj;
10729 fail:
10730 return NULL;
10731 }
10732
10733
10734 static PyObject *_wrap_Process_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
10735 PyObject *resultobj;
10736 int arg1 ;
10737 bool result;
10738 PyObject * obj0 = 0 ;
10739 char *kwnames[] = {
10740 (char *) "pid", NULL
10741 };
10742
10743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Exists",kwnames,&obj0)) goto fail;
10744 {
10745 arg1 = (int)(SWIG_As_int(obj0));
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 }
10748 {
10749 PyThreadState* __tstate = wxPyBeginAllowThreads();
10750 result = (bool)wxPyProcess::Exists(arg1);
10751
10752 wxPyEndAllowThreads(__tstate);
10753 if (PyErr_Occurred()) SWIG_fail;
10754 }
10755 {
10756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10757 }
10758 return resultobj;
10759 fail:
10760 return NULL;
10761 }
10762
10763
10764 static PyObject *_wrap_Process_Open(PyObject *, PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj;
10766 wxString *arg1 = 0 ;
10767 int arg2 = (int) wxEXEC_ASYNC ;
10768 wxPyProcess *result;
10769 bool temp1 = false ;
10770 PyObject * obj0 = 0 ;
10771 PyObject * obj1 = 0 ;
10772 char *kwnames[] = {
10773 (char *) "cmd",(char *) "flags", NULL
10774 };
10775
10776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Process_Open",kwnames,&obj0,&obj1)) goto fail;
10777 {
10778 arg1 = wxString_in_helper(obj0);
10779 if (arg1 == NULL) SWIG_fail;
10780 temp1 = true;
10781 }
10782 if (obj1) {
10783 {
10784 arg2 = (int)(SWIG_As_int(obj1));
10785 if (SWIG_arg_fail(2)) SWIG_fail;
10786 }
10787 }
10788 {
10789 PyThreadState* __tstate = wxPyBeginAllowThreads();
10790 result = (wxPyProcess *)wxPyProcess::Open((wxString const &)*arg1,arg2);
10791
10792 wxPyEndAllowThreads(__tstate);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 0);
10796 {
10797 if (temp1)
10798 delete arg1;
10799 }
10800 return resultobj;
10801 fail:
10802 {
10803 if (temp1)
10804 delete arg1;
10805 }
10806 return NULL;
10807 }
10808
10809
10810 static PyObject *_wrap_new_Process(PyObject *, PyObject *args, PyObject *kwargs) {
10811 PyObject *resultobj;
10812 wxEvtHandler *arg1 = (wxEvtHandler *) NULL ;
10813 int arg2 = (int) -1 ;
10814 wxPyProcess *result;
10815 PyObject * obj0 = 0 ;
10816 PyObject * obj1 = 0 ;
10817 char *kwnames[] = {
10818 (char *) "parent",(char *) "id", NULL
10819 };
10820
10821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Process",kwnames,&obj0,&obj1)) goto fail;
10822 if (obj0) {
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 }
10826 if (obj1) {
10827 {
10828 arg2 = (int)(SWIG_As_int(obj1));
10829 if (SWIG_arg_fail(2)) SWIG_fail;
10830 }
10831 }
10832 {
10833 PyThreadState* __tstate = wxPyBeginAllowThreads();
10834 result = (wxPyProcess *)new wxPyProcess(arg1,arg2);
10835
10836 wxPyEndAllowThreads(__tstate);
10837 if (PyErr_Occurred()) SWIG_fail;
10838 }
10839 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyProcess, 1);
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_Process__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10849 PyObject *arg2 = (PyObject *) 0 ;
10850 PyObject *arg3 = (PyObject *) 0 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 PyObject * obj2 = 0 ;
10854 char *kwnames[] = {
10855 (char *) "self",(char *) "self",(char *) "_class", NULL
10856 };
10857
10858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
10859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10860 if (SWIG_arg_fail(1)) SWIG_fail;
10861 arg2 = obj1;
10862 arg3 = obj2;
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 (arg1)->_setCallbackInfo(arg2,arg3);
10866
10867 wxPyEndAllowThreads(__tstate);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 Py_INCREF(Py_None); resultobj = Py_None;
10871 return resultobj;
10872 fail:
10873 return NULL;
10874 }
10875
10876
10877 static PyObject *_wrap_Process_base_OnTerminate(PyObject *, PyObject *args, PyObject *kwargs) {
10878 PyObject *resultobj;
10879 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10880 int arg2 ;
10881 int arg3 ;
10882 PyObject * obj0 = 0 ;
10883 PyObject * obj1 = 0 ;
10884 PyObject * obj2 = 0 ;
10885 char *kwnames[] = {
10886 (char *) "self",(char *) "pid",(char *) "status", NULL
10887 };
10888
10889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Process_base_OnTerminate",kwnames,&obj0,&obj1,&obj2)) goto fail;
10890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10891 if (SWIG_arg_fail(1)) SWIG_fail;
10892 {
10893 arg2 = (int)(SWIG_As_int(obj1));
10894 if (SWIG_arg_fail(2)) SWIG_fail;
10895 }
10896 {
10897 arg3 = (int)(SWIG_As_int(obj2));
10898 if (SWIG_arg_fail(3)) SWIG_fail;
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 (arg1)->base_OnTerminate(arg2,arg3);
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 Py_INCREF(Py_None); resultobj = Py_None;
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_Process_Redirect(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj;
10916 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10917 PyObject * obj0 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Redirect",kwnames,&obj0)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 PyThreadState* __tstate = wxPyBeginAllowThreads();
10927 (arg1)->Redirect();
10928
10929 wxPyEndAllowThreads(__tstate);
10930 if (PyErr_Occurred()) SWIG_fail;
10931 }
10932 Py_INCREF(Py_None); resultobj = Py_None;
10933 return resultobj;
10934 fail:
10935 return NULL;
10936 }
10937
10938
10939 static PyObject *_wrap_Process_IsRedirected(PyObject *, PyObject *args, PyObject *kwargs) {
10940 PyObject *resultobj;
10941 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10942 bool result;
10943 PyObject * obj0 = 0 ;
10944 char *kwnames[] = {
10945 (char *) "self", NULL
10946 };
10947
10948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsRedirected",kwnames,&obj0)) goto fail;
10949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10950 if (SWIG_arg_fail(1)) SWIG_fail;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 result = (bool)(arg1)->IsRedirected();
10954
10955 wxPyEndAllowThreads(__tstate);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 {
10959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Process_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj;
10969 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10970 PyObject * obj0 = 0 ;
10971 char *kwnames[] = {
10972 (char *) "self", NULL
10973 };
10974
10975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_Detach",kwnames,&obj0)) goto fail;
10976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
10977 if (SWIG_arg_fail(1)) SWIG_fail;
10978 {
10979 PyThreadState* __tstate = wxPyBeginAllowThreads();
10980 (arg1)->Detach();
10981
10982 wxPyEndAllowThreads(__tstate);
10983 if (PyErr_Occurred()) SWIG_fail;
10984 }
10985 Py_INCREF(Py_None); resultobj = Py_None;
10986 return resultobj;
10987 fail:
10988 return NULL;
10989 }
10990
10991
10992 static PyObject *_wrap_Process_GetInputStream(PyObject *, PyObject *args, PyObject *kwargs) {
10993 PyObject *resultobj;
10994 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
10995 wxInputStream *result;
10996 PyObject * obj0 = 0 ;
10997 char *kwnames[] = {
10998 (char *) "self", NULL
10999 };
11000
11001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetInputStream",kwnames,&obj0)) goto fail;
11002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11003 if (SWIG_arg_fail(1)) SWIG_fail;
11004 {
11005 PyThreadState* __tstate = wxPyBeginAllowThreads();
11006 result = (wxInputStream *)(arg1)->GetInputStream();
11007
11008 wxPyEndAllowThreads(__tstate);
11009 if (PyErr_Occurred()) SWIG_fail;
11010 }
11011 {
11012 wxPyInputStream * _ptr = NULL;
11013
11014 if (result) {
11015 _ptr = new wxPyInputStream(result);
11016 }
11017 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11018 }
11019 return resultobj;
11020 fail:
11021 return NULL;
11022 }
11023
11024
11025 static PyObject *_wrap_Process_GetErrorStream(PyObject *, PyObject *args, PyObject *kwargs) {
11026 PyObject *resultobj;
11027 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11028 wxInputStream *result;
11029 PyObject * obj0 = 0 ;
11030 char *kwnames[] = {
11031 (char *) "self", NULL
11032 };
11033
11034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetErrorStream",kwnames,&obj0)) goto fail;
11035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11036 if (SWIG_arg_fail(1)) SWIG_fail;
11037 {
11038 PyThreadState* __tstate = wxPyBeginAllowThreads();
11039 result = (wxInputStream *)(arg1)->GetErrorStream();
11040
11041 wxPyEndAllowThreads(__tstate);
11042 if (PyErr_Occurred()) SWIG_fail;
11043 }
11044 {
11045 wxPyInputStream * _ptr = NULL;
11046
11047 if (result) {
11048 _ptr = new wxPyInputStream(result);
11049 }
11050 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
11051 }
11052 return resultobj;
11053 fail:
11054 return NULL;
11055 }
11056
11057
11058 static PyObject *_wrap_Process_GetOutputStream(PyObject *, PyObject *args, PyObject *kwargs) {
11059 PyObject *resultobj;
11060 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11061 wxOutputStream *result;
11062 PyObject * obj0 = 0 ;
11063 char *kwnames[] = {
11064 (char *) "self", NULL
11065 };
11066
11067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_GetOutputStream",kwnames,&obj0)) goto fail;
11068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11069 if (SWIG_arg_fail(1)) SWIG_fail;
11070 {
11071 PyThreadState* __tstate = wxPyBeginAllowThreads();
11072 result = (wxOutputStream *)(arg1)->GetOutputStream();
11073
11074 wxPyEndAllowThreads(__tstate);
11075 if (PyErr_Occurred()) SWIG_fail;
11076 }
11077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxOutputStream, 0);
11078 return resultobj;
11079 fail:
11080 return NULL;
11081 }
11082
11083
11084 static PyObject *_wrap_Process_CloseOutput(PyObject *, PyObject *args, PyObject *kwargs) {
11085 PyObject *resultobj;
11086 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11087 PyObject * obj0 = 0 ;
11088 char *kwnames[] = {
11089 (char *) "self", NULL
11090 };
11091
11092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_CloseOutput",kwnames,&obj0)) goto fail;
11093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11094 if (SWIG_arg_fail(1)) SWIG_fail;
11095 {
11096 PyThreadState* __tstate = wxPyBeginAllowThreads();
11097 (arg1)->CloseOutput();
11098
11099 wxPyEndAllowThreads(__tstate);
11100 if (PyErr_Occurred()) SWIG_fail;
11101 }
11102 Py_INCREF(Py_None); resultobj = Py_None;
11103 return resultobj;
11104 fail:
11105 return NULL;
11106 }
11107
11108
11109 static PyObject *_wrap_Process_IsInputOpened(PyObject *, PyObject *args, PyObject *kwargs) {
11110 PyObject *resultobj;
11111 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11112 bool result;
11113 PyObject * obj0 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputOpened",kwnames,&obj0)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 PyThreadState* __tstate = wxPyBeginAllowThreads();
11123 result = (bool)((wxPyProcess const *)arg1)->IsInputOpened();
11124
11125 wxPyEndAllowThreads(__tstate);
11126 if (PyErr_Occurred()) SWIG_fail;
11127 }
11128 {
11129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11130 }
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 static PyObject *_wrap_Process_IsInputAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11138 PyObject *resultobj;
11139 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11140 bool result;
11141 PyObject * obj0 = 0 ;
11142 char *kwnames[] = {
11143 (char *) "self", NULL
11144 };
11145
11146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsInputAvailable",kwnames,&obj0)) goto fail;
11147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11148 if (SWIG_arg_fail(1)) SWIG_fail;
11149 {
11150 PyThreadState* __tstate = wxPyBeginAllowThreads();
11151 result = (bool)((wxPyProcess const *)arg1)->IsInputAvailable();
11152
11153 wxPyEndAllowThreads(__tstate);
11154 if (PyErr_Occurred()) SWIG_fail;
11155 }
11156 {
11157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11158 }
11159 return resultobj;
11160 fail:
11161 return NULL;
11162 }
11163
11164
11165 static PyObject *_wrap_Process_IsErrorAvailable(PyObject *, PyObject *args, PyObject *kwargs) {
11166 PyObject *resultobj;
11167 wxPyProcess *arg1 = (wxPyProcess *) 0 ;
11168 bool result;
11169 PyObject * obj0 = 0 ;
11170 char *kwnames[] = {
11171 (char *) "self", NULL
11172 };
11173
11174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Process_IsErrorAvailable",kwnames,&obj0)) goto fail;
11175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11176 if (SWIG_arg_fail(1)) SWIG_fail;
11177 {
11178 PyThreadState* __tstate = wxPyBeginAllowThreads();
11179 result = (bool)((wxPyProcess const *)arg1)->IsErrorAvailable();
11180
11181 wxPyEndAllowThreads(__tstate);
11182 if (PyErr_Occurred()) SWIG_fail;
11183 }
11184 {
11185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11186 }
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 static PyObject * Process_swigregister(PyObject *, PyObject *args) {
11194 PyObject *obj;
11195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11196 SWIG_TypeClientData(SWIGTYPE_p_wxPyProcess, obj);
11197 Py_INCREF(obj);
11198 return Py_BuildValue((char *)"");
11199 }
11200 static PyObject *_wrap_new_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
11201 PyObject *resultobj;
11202 int arg1 = (int) 0 ;
11203 int arg2 = (int) 0 ;
11204 int arg3 = (int) 0 ;
11205 wxProcessEvent *result;
11206 PyObject * obj0 = 0 ;
11207 PyObject * obj1 = 0 ;
11208 PyObject * obj2 = 0 ;
11209 char *kwnames[] = {
11210 (char *) "id",(char *) "pid",(char *) "exitcode", NULL
11211 };
11212
11213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ProcessEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
11214 if (obj0) {
11215 {
11216 arg1 = (int)(SWIG_As_int(obj0));
11217 if (SWIG_arg_fail(1)) SWIG_fail;
11218 }
11219 }
11220 if (obj1) {
11221 {
11222 arg2 = (int)(SWIG_As_int(obj1));
11223 if (SWIG_arg_fail(2)) SWIG_fail;
11224 }
11225 }
11226 if (obj2) {
11227 {
11228 arg3 = (int)(SWIG_As_int(obj2));
11229 if (SWIG_arg_fail(3)) SWIG_fail;
11230 }
11231 }
11232 {
11233 PyThreadState* __tstate = wxPyBeginAllowThreads();
11234 result = (wxProcessEvent *)new wxProcessEvent(arg1,arg2,arg3);
11235
11236 wxPyEndAllowThreads(__tstate);
11237 if (PyErr_Occurred()) SWIG_fail;
11238 }
11239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxProcessEvent, 1);
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 static PyObject *_wrap_ProcessEvent_GetPid(PyObject *, PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj;
11248 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11249 int result;
11250 PyObject * obj0 = 0 ;
11251 char *kwnames[] = {
11252 (char *) "self", NULL
11253 };
11254
11255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetPid",kwnames,&obj0)) goto fail;
11256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11257 if (SWIG_arg_fail(1)) SWIG_fail;
11258 {
11259 PyThreadState* __tstate = wxPyBeginAllowThreads();
11260 result = (int)(arg1)->GetPid();
11261
11262 wxPyEndAllowThreads(__tstate);
11263 if (PyErr_Occurred()) SWIG_fail;
11264 }
11265 {
11266 resultobj = SWIG_From_int((int)(result));
11267 }
11268 return resultobj;
11269 fail:
11270 return NULL;
11271 }
11272
11273
11274 static PyObject *_wrap_ProcessEvent_GetExitCode(PyObject *, PyObject *args, PyObject *kwargs) {
11275 PyObject *resultobj;
11276 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11277 int result;
11278 PyObject * obj0 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "self", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_GetExitCode",kwnames,&obj0)) goto fail;
11284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11285 if (SWIG_arg_fail(1)) SWIG_fail;
11286 {
11287 PyThreadState* __tstate = wxPyBeginAllowThreads();
11288 result = (int)(arg1)->GetExitCode();
11289
11290 wxPyEndAllowThreads(__tstate);
11291 if (PyErr_Occurred()) SWIG_fail;
11292 }
11293 {
11294 resultobj = SWIG_From_int((int)(result));
11295 }
11296 return resultobj;
11297 fail:
11298 return NULL;
11299 }
11300
11301
11302 static PyObject *_wrap_ProcessEvent_m_pid_set(PyObject *, PyObject *args, PyObject *kwargs) {
11303 PyObject *resultobj;
11304 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11305 int arg2 ;
11306 PyObject * obj0 = 0 ;
11307 PyObject * obj1 = 0 ;
11308 char *kwnames[] = {
11309 (char *) "self",(char *) "m_pid", NULL
11310 };
11311
11312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_pid_set",kwnames,&obj0,&obj1)) goto fail;
11313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11314 if (SWIG_arg_fail(1)) SWIG_fail;
11315 {
11316 arg2 = (int)(SWIG_As_int(obj1));
11317 if (SWIG_arg_fail(2)) SWIG_fail;
11318 }
11319 if (arg1) (arg1)->m_pid = arg2;
11320
11321 Py_INCREF(Py_None); resultobj = Py_None;
11322 return resultobj;
11323 fail:
11324 return NULL;
11325 }
11326
11327
11328 static PyObject *_wrap_ProcessEvent_m_pid_get(PyObject *, PyObject *args, PyObject *kwargs) {
11329 PyObject *resultobj;
11330 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11331 int result;
11332 PyObject * obj0 = 0 ;
11333 char *kwnames[] = {
11334 (char *) "self", NULL
11335 };
11336
11337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_pid_get",kwnames,&obj0)) goto fail;
11338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11339 if (SWIG_arg_fail(1)) SWIG_fail;
11340 result = (int) ((arg1)->m_pid);
11341
11342 {
11343 resultobj = SWIG_From_int((int)(result));
11344 }
11345 return resultobj;
11346 fail:
11347 return NULL;
11348 }
11349
11350
11351 static PyObject *_wrap_ProcessEvent_m_exitcode_set(PyObject *, PyObject *args, PyObject *kwargs) {
11352 PyObject *resultobj;
11353 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11354 int arg2 ;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 char *kwnames[] = {
11358 (char *) "self",(char *) "m_exitcode", NULL
11359 };
11360
11361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ProcessEvent_m_exitcode_set",kwnames,&obj0,&obj1)) goto fail;
11362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11363 if (SWIG_arg_fail(1)) SWIG_fail;
11364 {
11365 arg2 = (int)(SWIG_As_int(obj1));
11366 if (SWIG_arg_fail(2)) SWIG_fail;
11367 }
11368 if (arg1) (arg1)->m_exitcode = arg2;
11369
11370 Py_INCREF(Py_None); resultobj = Py_None;
11371 return resultobj;
11372 fail:
11373 return NULL;
11374 }
11375
11376
11377 static PyObject *_wrap_ProcessEvent_m_exitcode_get(PyObject *, PyObject *args, PyObject *kwargs) {
11378 PyObject *resultobj;
11379 wxProcessEvent *arg1 = (wxProcessEvent *) 0 ;
11380 int result;
11381 PyObject * obj0 = 0 ;
11382 char *kwnames[] = {
11383 (char *) "self", NULL
11384 };
11385
11386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ProcessEvent_m_exitcode_get",kwnames,&obj0)) goto fail;
11387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxProcessEvent, SWIG_POINTER_EXCEPTION | 0);
11388 if (SWIG_arg_fail(1)) SWIG_fail;
11389 result = (int) ((arg1)->m_exitcode);
11390
11391 {
11392 resultobj = SWIG_From_int((int)(result));
11393 }
11394 return resultobj;
11395 fail:
11396 return NULL;
11397 }
11398
11399
11400 static PyObject * ProcessEvent_swigregister(PyObject *, PyObject *args) {
11401 PyObject *obj;
11402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11403 SWIG_TypeClientData(SWIGTYPE_p_wxProcessEvent, obj);
11404 Py_INCREF(obj);
11405 return Py_BuildValue((char *)"");
11406 }
11407 static PyObject *_wrap_Execute(PyObject *, PyObject *args, PyObject *kwargs) {
11408 PyObject *resultobj;
11409 wxString *arg1 = 0 ;
11410 int arg2 = (int) wxEXEC_ASYNC ;
11411 wxPyProcess *arg3 = (wxPyProcess *) NULL ;
11412 long result;
11413 bool temp1 = false ;
11414 PyObject * obj0 = 0 ;
11415 PyObject * obj1 = 0 ;
11416 PyObject * obj2 = 0 ;
11417 char *kwnames[] = {
11418 (char *) "command",(char *) "flags",(char *) "process", NULL
11419 };
11420
11421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Execute",kwnames,&obj0,&obj1,&obj2)) goto fail;
11422 {
11423 arg1 = wxString_in_helper(obj0);
11424 if (arg1 == NULL) SWIG_fail;
11425 temp1 = true;
11426 }
11427 if (obj1) {
11428 {
11429 arg2 = (int)(SWIG_As_int(obj1));
11430 if (SWIG_arg_fail(2)) SWIG_fail;
11431 }
11432 }
11433 if (obj2) {
11434 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxPyProcess, SWIG_POINTER_EXCEPTION | 0);
11435 if (SWIG_arg_fail(3)) SWIG_fail;
11436 }
11437 {
11438 if (!wxPyCheckForApp()) SWIG_fail;
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (long)wxExecute((wxString const &)*arg1,arg2,arg3);
11441
11442 wxPyEndAllowThreads(__tstate);
11443 if (PyErr_Occurred()) SWIG_fail;
11444 }
11445 {
11446 resultobj = SWIG_From_long((long)(result));
11447 }
11448 {
11449 if (temp1)
11450 delete arg1;
11451 }
11452 return resultobj;
11453 fail:
11454 {
11455 if (temp1)
11456 delete arg1;
11457 }
11458 return NULL;
11459 }
11460
11461
11462 static PyObject *_wrap_Kill(PyObject *, PyObject *args, PyObject *kwargs) {
11463 PyObject *resultobj;
11464 long arg1 ;
11465 wxSignal arg2 = (wxSignal) wxSIGTERM ;
11466 wxKillError *arg3 = (wxKillError *) 0 ;
11467 int arg4 = (int) wxKILL_NOCHILDREN ;
11468 int result;
11469 wxKillError temp3 ;
11470 PyObject * obj0 = 0 ;
11471 PyObject * obj1 = 0 ;
11472 PyObject * obj2 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "pid",(char *) "sig",(char *) "flags", NULL
11475 };
11476
11477 {
11478 arg3 = &temp3;
11479 }
11480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Kill",kwnames,&obj0,&obj1,&obj2)) goto fail;
11481 {
11482 arg1 = (long)(SWIG_As_long(obj0));
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 }
11485 if (obj1) {
11486 {
11487 arg2 = (wxSignal)(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 }
11491 if (obj2) {
11492 {
11493 arg4 = (int)(SWIG_As_int(obj2));
11494 if (SWIG_arg_fail(4)) SWIG_fail;
11495 }
11496 }
11497 {
11498 PyThreadState* __tstate = wxPyBeginAllowThreads();
11499 result = (int)wxKill(arg1,(wxSignal )arg2,arg3,arg4);
11500
11501 wxPyEndAllowThreads(__tstate);
11502 if (PyErr_Occurred()) SWIG_fail;
11503 }
11504 {
11505 resultobj = SWIG_From_int((int)(result));
11506 }
11507 {
11508 PyObject* o;
11509 o = PyInt_FromLong((long) (*arg3));
11510 resultobj = t_output_helper(resultobj, o);
11511 }
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 static PyObject *_wrap_new_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11519 PyObject *resultobj;
11520 int arg1 = (int) wxJOYSTICK1 ;
11521 wxJoystick *result;
11522 PyObject * obj0 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "joystick", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Joystick",kwnames,&obj0)) goto fail;
11528 if (obj0) {
11529 {
11530 arg1 = (int)(SWIG_As_int(obj0));
11531 if (SWIG_arg_fail(1)) SWIG_fail;
11532 }
11533 }
11534 {
11535 if (!wxPyCheckForApp()) SWIG_fail;
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (wxJoystick *)new wxJoystick(arg1);
11538
11539 wxPyEndAllowThreads(__tstate);
11540 if (PyErr_Occurred()) SWIG_fail;
11541 }
11542 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystick, 1);
11543 return resultobj;
11544 fail:
11545 return NULL;
11546 }
11547
11548
11549 static PyObject *_wrap_delete_Joystick(PyObject *, PyObject *args, PyObject *kwargs) {
11550 PyObject *resultobj;
11551 wxJoystick *arg1 = (wxJoystick *) 0 ;
11552 PyObject * obj0 = 0 ;
11553 char *kwnames[] = {
11554 (char *) "self", NULL
11555 };
11556
11557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Joystick",kwnames,&obj0)) goto fail;
11558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11559 if (SWIG_arg_fail(1)) SWIG_fail;
11560 {
11561 PyThreadState* __tstate = wxPyBeginAllowThreads();
11562 delete arg1;
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 Py_INCREF(Py_None); resultobj = Py_None;
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Joystick_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxJoystick *arg1 = (wxJoystick *) 0 ;
11577 wxPoint result;
11578 PyObject * obj0 = 0 ;
11579 char *kwnames[] = {
11580 (char *) "self", NULL
11581 };
11582
11583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPosition",kwnames,&obj0)) goto fail;
11584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11585 if (SWIG_arg_fail(1)) SWIG_fail;
11586 {
11587 PyThreadState* __tstate = wxPyBeginAllowThreads();
11588 result = (arg1)->GetPosition();
11589
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 wxPoint * resultptr;
11595 resultptr = new wxPoint((wxPoint &)(result));
11596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
11597 }
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 static PyObject *_wrap_Joystick_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj;
11606 wxJoystick *arg1 = (wxJoystick *) 0 ;
11607 int result;
11608 PyObject * obj0 = 0 ;
11609 char *kwnames[] = {
11610 (char *) "self", NULL
11611 };
11612
11613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZPosition",kwnames,&obj0)) goto fail;
11614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11615 if (SWIG_arg_fail(1)) SWIG_fail;
11616 {
11617 PyThreadState* __tstate = wxPyBeginAllowThreads();
11618 result = (int)(arg1)->GetZPosition();
11619
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 {
11624 resultobj = SWIG_From_int((int)(result));
11625 }
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 static PyObject *_wrap_Joystick_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj;
11634 wxJoystick *arg1 = (wxJoystick *) 0 ;
11635 int result;
11636 PyObject * obj0 = 0 ;
11637 char *kwnames[] = {
11638 (char *) "self", NULL
11639 };
11640
11641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetButtonState",kwnames,&obj0)) goto fail;
11642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11643 if (SWIG_arg_fail(1)) SWIG_fail;
11644 {
11645 PyThreadState* __tstate = wxPyBeginAllowThreads();
11646 result = (int)(arg1)->GetButtonState();
11647
11648 wxPyEndAllowThreads(__tstate);
11649 if (PyErr_Occurred()) SWIG_fail;
11650 }
11651 {
11652 resultobj = SWIG_From_int((int)(result));
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_Joystick_GetPOVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj;
11662 wxJoystick *arg1 = (wxJoystick *) 0 ;
11663 int result;
11664 PyObject * obj0 = 0 ;
11665 char *kwnames[] = {
11666 (char *) "self", NULL
11667 };
11668
11669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVPosition",kwnames,&obj0)) goto fail;
11670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11671 if (SWIG_arg_fail(1)) SWIG_fail;
11672 {
11673 PyThreadState* __tstate = wxPyBeginAllowThreads();
11674 result = (int)(arg1)->GetPOVPosition();
11675
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 {
11680 resultobj = SWIG_From_int((int)(result));
11681 }
11682 return resultobj;
11683 fail:
11684 return NULL;
11685 }
11686
11687
11688 static PyObject *_wrap_Joystick_GetPOVCTSPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj;
11690 wxJoystick *arg1 = (wxJoystick *) 0 ;
11691 int result;
11692 PyObject * obj0 = 0 ;
11693 char *kwnames[] = {
11694 (char *) "self", NULL
11695 };
11696
11697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPOVCTSPosition",kwnames,&obj0)) goto fail;
11698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11699 if (SWIG_arg_fail(1)) SWIG_fail;
11700 {
11701 PyThreadState* __tstate = wxPyBeginAllowThreads();
11702 result = (int)(arg1)->GetPOVCTSPosition();
11703
11704 wxPyEndAllowThreads(__tstate);
11705 if (PyErr_Occurred()) SWIG_fail;
11706 }
11707 {
11708 resultobj = SWIG_From_int((int)(result));
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 static PyObject *_wrap_Joystick_GetRudderPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11717 PyObject *resultobj;
11718 wxJoystick *arg1 = (wxJoystick *) 0 ;
11719 int result;
11720 PyObject * obj0 = 0 ;
11721 char *kwnames[] = {
11722 (char *) "self", NULL
11723 };
11724
11725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderPosition",kwnames,&obj0)) goto fail;
11726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11727 if (SWIG_arg_fail(1)) SWIG_fail;
11728 {
11729 PyThreadState* __tstate = wxPyBeginAllowThreads();
11730 result = (int)(arg1)->GetRudderPosition();
11731
11732 wxPyEndAllowThreads(__tstate);
11733 if (PyErr_Occurred()) SWIG_fail;
11734 }
11735 {
11736 resultobj = SWIG_From_int((int)(result));
11737 }
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 static PyObject *_wrap_Joystick_GetUPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj;
11746 wxJoystick *arg1 = (wxJoystick *) 0 ;
11747 int result;
11748 PyObject * obj0 = 0 ;
11749 char *kwnames[] = {
11750 (char *) "self", NULL
11751 };
11752
11753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUPosition",kwnames,&obj0)) goto fail;
11754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11755 if (SWIG_arg_fail(1)) SWIG_fail;
11756 {
11757 PyThreadState* __tstate = wxPyBeginAllowThreads();
11758 result = (int)(arg1)->GetUPosition();
11759
11760 wxPyEndAllowThreads(__tstate);
11761 if (PyErr_Occurred()) SWIG_fail;
11762 }
11763 {
11764 resultobj = SWIG_From_int((int)(result));
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Joystick_GetVPosition(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj;
11774 wxJoystick *arg1 = (wxJoystick *) 0 ;
11775 int result;
11776 PyObject * obj0 = 0 ;
11777 char *kwnames[] = {
11778 (char *) "self", NULL
11779 };
11780
11781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVPosition",kwnames,&obj0)) goto fail;
11782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11783 if (SWIG_arg_fail(1)) SWIG_fail;
11784 {
11785 PyThreadState* __tstate = wxPyBeginAllowThreads();
11786 result = (int)(arg1)->GetVPosition();
11787
11788 wxPyEndAllowThreads(__tstate);
11789 if (PyErr_Occurred()) SWIG_fail;
11790 }
11791 {
11792 resultobj = SWIG_From_int((int)(result));
11793 }
11794 return resultobj;
11795 fail:
11796 return NULL;
11797 }
11798
11799
11800 static PyObject *_wrap_Joystick_GetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11801 PyObject *resultobj;
11802 wxJoystick *arg1 = (wxJoystick *) 0 ;
11803 int result;
11804 PyObject * obj0 = 0 ;
11805 char *kwnames[] = {
11806 (char *) "self", NULL
11807 };
11808
11809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMovementThreshold",kwnames,&obj0)) goto fail;
11810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11811 if (SWIG_arg_fail(1)) SWIG_fail;
11812 {
11813 PyThreadState* __tstate = wxPyBeginAllowThreads();
11814 result = (int)(arg1)->GetMovementThreshold();
11815
11816 wxPyEndAllowThreads(__tstate);
11817 if (PyErr_Occurred()) SWIG_fail;
11818 }
11819 {
11820 resultobj = SWIG_From_int((int)(result));
11821 }
11822 return resultobj;
11823 fail:
11824 return NULL;
11825 }
11826
11827
11828 static PyObject *_wrap_Joystick_SetMovementThreshold(PyObject *, PyObject *args, PyObject *kwargs) {
11829 PyObject *resultobj;
11830 wxJoystick *arg1 = (wxJoystick *) 0 ;
11831 int arg2 ;
11832 PyObject * obj0 = 0 ;
11833 PyObject * obj1 = 0 ;
11834 char *kwnames[] = {
11835 (char *) "self",(char *) "threshold", NULL
11836 };
11837
11838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Joystick_SetMovementThreshold",kwnames,&obj0,&obj1)) goto fail;
11839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11840 if (SWIG_arg_fail(1)) SWIG_fail;
11841 {
11842 arg2 = (int)(SWIG_As_int(obj1));
11843 if (SWIG_arg_fail(2)) SWIG_fail;
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 (arg1)->SetMovementThreshold(arg2);
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 Py_INCREF(Py_None); resultobj = Py_None;
11853 return resultobj;
11854 fail:
11855 return NULL;
11856 }
11857
11858
11859 static PyObject *_wrap_Joystick_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
11860 PyObject *resultobj;
11861 wxJoystick *arg1 = (wxJoystick *) 0 ;
11862 bool result;
11863 PyObject * obj0 = 0 ;
11864 char *kwnames[] = {
11865 (char *) "self", NULL
11866 };
11867
11868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_IsOk",kwnames,&obj0)) goto fail;
11869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11870 if (SWIG_arg_fail(1)) SWIG_fail;
11871 {
11872 PyThreadState* __tstate = wxPyBeginAllowThreads();
11873 result = (bool)(arg1)->IsOk();
11874
11875 wxPyEndAllowThreads(__tstate);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 {
11879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11880 }
11881 return resultobj;
11882 fail:
11883 return NULL;
11884 }
11885
11886
11887 static PyObject *_wrap_Joystick_GetNumberJoysticks(PyObject *, PyObject *args, PyObject *kwargs) {
11888 PyObject *resultobj;
11889 wxJoystick *arg1 = (wxJoystick *) 0 ;
11890 int result;
11891 PyObject * obj0 = 0 ;
11892 char *kwnames[] = {
11893 (char *) "self", NULL
11894 };
11895
11896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberJoysticks",kwnames,&obj0)) goto fail;
11897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11898 if (SWIG_arg_fail(1)) SWIG_fail;
11899 {
11900 PyThreadState* __tstate = wxPyBeginAllowThreads();
11901 result = (int)(arg1)->GetNumberJoysticks();
11902
11903 wxPyEndAllowThreads(__tstate);
11904 if (PyErr_Occurred()) SWIG_fail;
11905 }
11906 {
11907 resultobj = SWIG_From_int((int)(result));
11908 }
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 static PyObject *_wrap_Joystick_GetManufacturerId(PyObject *, PyObject *args, PyObject *kwargs) {
11916 PyObject *resultobj;
11917 wxJoystick *arg1 = (wxJoystick *) 0 ;
11918 int result;
11919 PyObject * obj0 = 0 ;
11920 char *kwnames[] = {
11921 (char *) "self", NULL
11922 };
11923
11924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetManufacturerId",kwnames,&obj0)) goto fail;
11925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11926 if (SWIG_arg_fail(1)) SWIG_fail;
11927 {
11928 PyThreadState* __tstate = wxPyBeginAllowThreads();
11929 result = (int)(arg1)->GetManufacturerId();
11930
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 {
11935 resultobj = SWIG_From_int((int)(result));
11936 }
11937 return resultobj;
11938 fail:
11939 return NULL;
11940 }
11941
11942
11943 static PyObject *_wrap_Joystick_GetProductId(PyObject *, PyObject *args, PyObject *kwargs) {
11944 PyObject *resultobj;
11945 wxJoystick *arg1 = (wxJoystick *) 0 ;
11946 int result;
11947 PyObject * obj0 = 0 ;
11948 char *kwnames[] = {
11949 (char *) "self", NULL
11950 };
11951
11952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductId",kwnames,&obj0)) goto fail;
11953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11954 if (SWIG_arg_fail(1)) SWIG_fail;
11955 {
11956 PyThreadState* __tstate = wxPyBeginAllowThreads();
11957 result = (int)(arg1)->GetProductId();
11958
11959 wxPyEndAllowThreads(__tstate);
11960 if (PyErr_Occurred()) SWIG_fail;
11961 }
11962 {
11963 resultobj = SWIG_From_int((int)(result));
11964 }
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 static PyObject *_wrap_Joystick_GetProductName(PyObject *, PyObject *args, PyObject *kwargs) {
11972 PyObject *resultobj;
11973 wxJoystick *arg1 = (wxJoystick *) 0 ;
11974 wxString result;
11975 PyObject * obj0 = 0 ;
11976 char *kwnames[] = {
11977 (char *) "self", NULL
11978 };
11979
11980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetProductName",kwnames,&obj0)) goto fail;
11981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
11982 if (SWIG_arg_fail(1)) SWIG_fail;
11983 {
11984 PyThreadState* __tstate = wxPyBeginAllowThreads();
11985 result = (arg1)->GetProductName();
11986
11987 wxPyEndAllowThreads(__tstate);
11988 if (PyErr_Occurred()) SWIG_fail;
11989 }
11990 {
11991 #if wxUSE_UNICODE
11992 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11993 #else
11994 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11995 #endif
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Joystick_GetXMin(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxJoystick *arg1 = (wxJoystick *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMin",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetXMin();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Joystick_GetYMin(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxJoystick *arg1 = (wxJoystick *) 0 ;
12034 int result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMin",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (int)(arg1)->GetYMin();
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 resultobj = SWIG_From_int((int)(result));
12052 }
12053 return resultobj;
12054 fail:
12055 return NULL;
12056 }
12057
12058
12059 static PyObject *_wrap_Joystick_GetZMin(PyObject *, PyObject *args, PyObject *kwargs) {
12060 PyObject *resultobj;
12061 wxJoystick *arg1 = (wxJoystick *) 0 ;
12062 int result;
12063 PyObject * obj0 = 0 ;
12064 char *kwnames[] = {
12065 (char *) "self", NULL
12066 };
12067
12068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMin",kwnames,&obj0)) goto fail;
12069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12070 if (SWIG_arg_fail(1)) SWIG_fail;
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (int)(arg1)->GetZMin();
12074
12075 wxPyEndAllowThreads(__tstate);
12076 if (PyErr_Occurred()) SWIG_fail;
12077 }
12078 {
12079 resultobj = SWIG_From_int((int)(result));
12080 }
12081 return resultobj;
12082 fail:
12083 return NULL;
12084 }
12085
12086
12087 static PyObject *_wrap_Joystick_GetXMax(PyObject *, PyObject *args, PyObject *kwargs) {
12088 PyObject *resultobj;
12089 wxJoystick *arg1 = (wxJoystick *) 0 ;
12090 int result;
12091 PyObject * obj0 = 0 ;
12092 char *kwnames[] = {
12093 (char *) "self", NULL
12094 };
12095
12096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetXMax",kwnames,&obj0)) goto fail;
12097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12098 if (SWIG_arg_fail(1)) SWIG_fail;
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 result = (int)(arg1)->GetXMax();
12102
12103 wxPyEndAllowThreads(__tstate);
12104 if (PyErr_Occurred()) SWIG_fail;
12105 }
12106 {
12107 resultobj = SWIG_From_int((int)(result));
12108 }
12109 return resultobj;
12110 fail:
12111 return NULL;
12112 }
12113
12114
12115 static PyObject *_wrap_Joystick_GetYMax(PyObject *, PyObject *args, PyObject *kwargs) {
12116 PyObject *resultobj;
12117 wxJoystick *arg1 = (wxJoystick *) 0 ;
12118 int result;
12119 PyObject * obj0 = 0 ;
12120 char *kwnames[] = {
12121 (char *) "self", NULL
12122 };
12123
12124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetYMax",kwnames,&obj0)) goto fail;
12125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12126 if (SWIG_arg_fail(1)) SWIG_fail;
12127 {
12128 PyThreadState* __tstate = wxPyBeginAllowThreads();
12129 result = (int)(arg1)->GetYMax();
12130
12131 wxPyEndAllowThreads(__tstate);
12132 if (PyErr_Occurred()) SWIG_fail;
12133 }
12134 {
12135 resultobj = SWIG_From_int((int)(result));
12136 }
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 static PyObject *_wrap_Joystick_GetZMax(PyObject *, PyObject *args, PyObject *kwargs) {
12144 PyObject *resultobj;
12145 wxJoystick *arg1 = (wxJoystick *) 0 ;
12146 int result;
12147 PyObject * obj0 = 0 ;
12148 char *kwnames[] = {
12149 (char *) "self", NULL
12150 };
12151
12152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetZMax",kwnames,&obj0)) goto fail;
12153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12154 if (SWIG_arg_fail(1)) SWIG_fail;
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (int)(arg1)->GetZMax();
12158
12159 wxPyEndAllowThreads(__tstate);
12160 if (PyErr_Occurred()) SWIG_fail;
12161 }
12162 {
12163 resultobj = SWIG_From_int((int)(result));
12164 }
12165 return resultobj;
12166 fail:
12167 return NULL;
12168 }
12169
12170
12171 static PyObject *_wrap_Joystick_GetNumberButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12172 PyObject *resultobj;
12173 wxJoystick *arg1 = (wxJoystick *) 0 ;
12174 int result;
12175 PyObject * obj0 = 0 ;
12176 char *kwnames[] = {
12177 (char *) "self", NULL
12178 };
12179
12180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberButtons",kwnames,&obj0)) goto fail;
12181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12182 if (SWIG_arg_fail(1)) SWIG_fail;
12183 {
12184 PyThreadState* __tstate = wxPyBeginAllowThreads();
12185 result = (int)(arg1)->GetNumberButtons();
12186
12187 wxPyEndAllowThreads(__tstate);
12188 if (PyErr_Occurred()) SWIG_fail;
12189 }
12190 {
12191 resultobj = SWIG_From_int((int)(result));
12192 }
12193 return resultobj;
12194 fail:
12195 return NULL;
12196 }
12197
12198
12199 static PyObject *_wrap_Joystick_GetNumberAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12200 PyObject *resultobj;
12201 wxJoystick *arg1 = (wxJoystick *) 0 ;
12202 int result;
12203 PyObject * obj0 = 0 ;
12204 char *kwnames[] = {
12205 (char *) "self", NULL
12206 };
12207
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetNumberAxes",kwnames,&obj0)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 {
12212 PyThreadState* __tstate = wxPyBeginAllowThreads();
12213 result = (int)(arg1)->GetNumberAxes();
12214
12215 wxPyEndAllowThreads(__tstate);
12216 if (PyErr_Occurred()) SWIG_fail;
12217 }
12218 {
12219 resultobj = SWIG_From_int((int)(result));
12220 }
12221 return resultobj;
12222 fail:
12223 return NULL;
12224 }
12225
12226
12227 static PyObject *_wrap_Joystick_GetMaxButtons(PyObject *, PyObject *args, PyObject *kwargs) {
12228 PyObject *resultobj;
12229 wxJoystick *arg1 = (wxJoystick *) 0 ;
12230 int result;
12231 PyObject * obj0 = 0 ;
12232 char *kwnames[] = {
12233 (char *) "self", NULL
12234 };
12235
12236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxButtons",kwnames,&obj0)) goto fail;
12237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12238 if (SWIG_arg_fail(1)) SWIG_fail;
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 result = (int)(arg1)->GetMaxButtons();
12242
12243 wxPyEndAllowThreads(__tstate);
12244 if (PyErr_Occurred()) SWIG_fail;
12245 }
12246 {
12247 resultobj = SWIG_From_int((int)(result));
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Joystick_GetMaxAxes(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxJoystick *arg1 = (wxJoystick *) 0 ;
12258 int result;
12259 PyObject * obj0 = 0 ;
12260 char *kwnames[] = {
12261 (char *) "self", NULL
12262 };
12263
12264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetMaxAxes",kwnames,&obj0)) goto fail;
12265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12266 if (SWIG_arg_fail(1)) SWIG_fail;
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (int)(arg1)->GetMaxAxes();
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = SWIG_From_int((int)(result));
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Joystick_GetPollingMin(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxJoystick *arg1 = (wxJoystick *) 0 ;
12286 int result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMin",kwnames,&obj0)) goto fail;
12293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12294 if (SWIG_arg_fail(1)) SWIG_fail;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (int)(arg1)->GetPollingMin();
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = SWIG_From_int((int)(result));
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Joystick_GetPollingMax(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxJoystick *arg1 = (wxJoystick *) 0 ;
12314 int result;
12315 PyObject * obj0 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetPollingMax",kwnames,&obj0)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (int)(arg1)->GetPollingMax();
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = SWIG_From_int((int)(result));
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Joystick_GetRudderMin(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxJoystick *arg1 = (wxJoystick *) 0 ;
12342 int result;
12343 PyObject * obj0 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "self", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMin",kwnames,&obj0)) goto fail;
12349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12350 if (SWIG_arg_fail(1)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (int)(arg1)->GetRudderMin();
12354
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 resultobj = SWIG_From_int((int)(result));
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 static PyObject *_wrap_Joystick_GetRudderMax(PyObject *, PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj;
12369 wxJoystick *arg1 = (wxJoystick *) 0 ;
12370 int result;
12371 PyObject * obj0 = 0 ;
12372 char *kwnames[] = {
12373 (char *) "self", NULL
12374 };
12375
12376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetRudderMax",kwnames,&obj0)) goto fail;
12377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12378 if (SWIG_arg_fail(1)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = (int)(arg1)->GetRudderMax();
12382
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 resultobj = SWIG_From_int((int)(result));
12388 }
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 static PyObject *_wrap_Joystick_GetUMin(PyObject *, PyObject *args, PyObject *kwargs) {
12396 PyObject *resultobj;
12397 wxJoystick *arg1 = (wxJoystick *) 0 ;
12398 int result;
12399 PyObject * obj0 = 0 ;
12400 char *kwnames[] = {
12401 (char *) "self", NULL
12402 };
12403
12404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMin",kwnames,&obj0)) goto fail;
12405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12406 if (SWIG_arg_fail(1)) SWIG_fail;
12407 {
12408 PyThreadState* __tstate = wxPyBeginAllowThreads();
12409 result = (int)(arg1)->GetUMin();
12410
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 resultobj = SWIG_From_int((int)(result));
12416 }
12417 return resultobj;
12418 fail:
12419 return NULL;
12420 }
12421
12422
12423 static PyObject *_wrap_Joystick_GetUMax(PyObject *, PyObject *args, PyObject *kwargs) {
12424 PyObject *resultobj;
12425 wxJoystick *arg1 = (wxJoystick *) 0 ;
12426 int result;
12427 PyObject * obj0 = 0 ;
12428 char *kwnames[] = {
12429 (char *) "self", NULL
12430 };
12431
12432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetUMax",kwnames,&obj0)) goto fail;
12433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12434 if (SWIG_arg_fail(1)) SWIG_fail;
12435 {
12436 PyThreadState* __tstate = wxPyBeginAllowThreads();
12437 result = (int)(arg1)->GetUMax();
12438
12439 wxPyEndAllowThreads(__tstate);
12440 if (PyErr_Occurred()) SWIG_fail;
12441 }
12442 {
12443 resultobj = SWIG_From_int((int)(result));
12444 }
12445 return resultobj;
12446 fail:
12447 return NULL;
12448 }
12449
12450
12451 static PyObject *_wrap_Joystick_GetVMin(PyObject *, PyObject *args, PyObject *kwargs) {
12452 PyObject *resultobj;
12453 wxJoystick *arg1 = (wxJoystick *) 0 ;
12454 int result;
12455 PyObject * obj0 = 0 ;
12456 char *kwnames[] = {
12457 (char *) "self", NULL
12458 };
12459
12460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMin",kwnames,&obj0)) goto fail;
12461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12462 if (SWIG_arg_fail(1)) SWIG_fail;
12463 {
12464 PyThreadState* __tstate = wxPyBeginAllowThreads();
12465 result = (int)(arg1)->GetVMin();
12466
12467 wxPyEndAllowThreads(__tstate);
12468 if (PyErr_Occurred()) SWIG_fail;
12469 }
12470 {
12471 resultobj = SWIG_From_int((int)(result));
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 static PyObject *_wrap_Joystick_GetVMax(PyObject *, PyObject *args, PyObject *kwargs) {
12480 PyObject *resultobj;
12481 wxJoystick *arg1 = (wxJoystick *) 0 ;
12482 int result;
12483 PyObject * obj0 = 0 ;
12484 char *kwnames[] = {
12485 (char *) "self", NULL
12486 };
12487
12488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_GetVMax",kwnames,&obj0)) goto fail;
12489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12490 if (SWIG_arg_fail(1)) SWIG_fail;
12491 {
12492 PyThreadState* __tstate = wxPyBeginAllowThreads();
12493 result = (int)(arg1)->GetVMax();
12494
12495 wxPyEndAllowThreads(__tstate);
12496 if (PyErr_Occurred()) SWIG_fail;
12497 }
12498 {
12499 resultobj = SWIG_From_int((int)(result));
12500 }
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 static PyObject *_wrap_Joystick_HasRudder(PyObject *, PyObject *args, PyObject *kwargs) {
12508 PyObject *resultobj;
12509 wxJoystick *arg1 = (wxJoystick *) 0 ;
12510 bool result;
12511 PyObject * obj0 = 0 ;
12512 char *kwnames[] = {
12513 (char *) "self", NULL
12514 };
12515
12516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasRudder",kwnames,&obj0)) goto fail;
12517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12518 if (SWIG_arg_fail(1)) SWIG_fail;
12519 {
12520 PyThreadState* __tstate = wxPyBeginAllowThreads();
12521 result = (bool)(arg1)->HasRudder();
12522
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 {
12527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12528 }
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 static PyObject *_wrap_Joystick_HasZ(PyObject *, PyObject *args, PyObject *kwargs) {
12536 PyObject *resultobj;
12537 wxJoystick *arg1 = (wxJoystick *) 0 ;
12538 bool result;
12539 PyObject * obj0 = 0 ;
12540 char *kwnames[] = {
12541 (char *) "self", NULL
12542 };
12543
12544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasZ",kwnames,&obj0)) goto fail;
12545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12546 if (SWIG_arg_fail(1)) SWIG_fail;
12547 {
12548 PyThreadState* __tstate = wxPyBeginAllowThreads();
12549 result = (bool)(arg1)->HasZ();
12550
12551 wxPyEndAllowThreads(__tstate);
12552 if (PyErr_Occurred()) SWIG_fail;
12553 }
12554 {
12555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12556 }
12557 return resultobj;
12558 fail:
12559 return NULL;
12560 }
12561
12562
12563 static PyObject *_wrap_Joystick_HasU(PyObject *, PyObject *args, PyObject *kwargs) {
12564 PyObject *resultobj;
12565 wxJoystick *arg1 = (wxJoystick *) 0 ;
12566 bool result;
12567 PyObject * obj0 = 0 ;
12568 char *kwnames[] = {
12569 (char *) "self", NULL
12570 };
12571
12572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasU",kwnames,&obj0)) goto fail;
12573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12574 if (SWIG_arg_fail(1)) SWIG_fail;
12575 {
12576 PyThreadState* __tstate = wxPyBeginAllowThreads();
12577 result = (bool)(arg1)->HasU();
12578
12579 wxPyEndAllowThreads(__tstate);
12580 if (PyErr_Occurred()) SWIG_fail;
12581 }
12582 {
12583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12584 }
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 static PyObject *_wrap_Joystick_HasV(PyObject *, PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj;
12593 wxJoystick *arg1 = (wxJoystick *) 0 ;
12594 bool result;
12595 PyObject * obj0 = 0 ;
12596 char *kwnames[] = {
12597 (char *) "self", NULL
12598 };
12599
12600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasV",kwnames,&obj0)) goto fail;
12601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12602 if (SWIG_arg_fail(1)) SWIG_fail;
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (bool)(arg1)->HasV();
12606
12607 wxPyEndAllowThreads(__tstate);
12608 if (PyErr_Occurred()) SWIG_fail;
12609 }
12610 {
12611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12612 }
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 static PyObject *_wrap_Joystick_HasPOV(PyObject *, PyObject *args, PyObject *kwargs) {
12620 PyObject *resultobj;
12621 wxJoystick *arg1 = (wxJoystick *) 0 ;
12622 bool result;
12623 PyObject * obj0 = 0 ;
12624 char *kwnames[] = {
12625 (char *) "self", NULL
12626 };
12627
12628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV",kwnames,&obj0)) goto fail;
12629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12630 if (SWIG_arg_fail(1)) SWIG_fail;
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->HasPOV();
12634
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 return resultobj;
12642 fail:
12643 return NULL;
12644 }
12645
12646
12647 static PyObject *_wrap_Joystick_HasPOV4Dir(PyObject *, PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj;
12649 wxJoystick *arg1 = (wxJoystick *) 0 ;
12650 bool result;
12651 PyObject * obj0 = 0 ;
12652 char *kwnames[] = {
12653 (char *) "self", NULL
12654 };
12655
12656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOV4Dir",kwnames,&obj0)) goto fail;
12657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12658 if (SWIG_arg_fail(1)) SWIG_fail;
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (bool)(arg1)->HasPOV4Dir();
12662
12663 wxPyEndAllowThreads(__tstate);
12664 if (PyErr_Occurred()) SWIG_fail;
12665 }
12666 {
12667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12668 }
12669 return resultobj;
12670 fail:
12671 return NULL;
12672 }
12673
12674
12675 static PyObject *_wrap_Joystick_HasPOVCTS(PyObject *, PyObject *args, PyObject *kwargs) {
12676 PyObject *resultobj;
12677 wxJoystick *arg1 = (wxJoystick *) 0 ;
12678 bool result;
12679 PyObject * obj0 = 0 ;
12680 char *kwnames[] = {
12681 (char *) "self", NULL
12682 };
12683
12684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_HasPOVCTS",kwnames,&obj0)) goto fail;
12685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12686 if (SWIG_arg_fail(1)) SWIG_fail;
12687 {
12688 PyThreadState* __tstate = wxPyBeginAllowThreads();
12689 result = (bool)(arg1)->HasPOVCTS();
12690
12691 wxPyEndAllowThreads(__tstate);
12692 if (PyErr_Occurred()) SWIG_fail;
12693 }
12694 {
12695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12696 }
12697 return resultobj;
12698 fail:
12699 return NULL;
12700 }
12701
12702
12703 static PyObject *_wrap_Joystick_SetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12704 PyObject *resultobj;
12705 wxJoystick *arg1 = (wxJoystick *) 0 ;
12706 wxWindow *arg2 = (wxWindow *) 0 ;
12707 int arg3 = (int) 0 ;
12708 bool result;
12709 PyObject * obj0 = 0 ;
12710 PyObject * obj1 = 0 ;
12711 PyObject * obj2 = 0 ;
12712 char *kwnames[] = {
12713 (char *) "self",(char *) "win",(char *) "pollingFreq", NULL
12714 };
12715
12716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Joystick_SetCapture",kwnames,&obj0,&obj1,&obj2)) goto fail;
12717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12718 if (SWIG_arg_fail(1)) SWIG_fail;
12719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
12720 if (SWIG_arg_fail(2)) SWIG_fail;
12721 if (obj2) {
12722 {
12723 arg3 = (int)(SWIG_As_int(obj2));
12724 if (SWIG_arg_fail(3)) SWIG_fail;
12725 }
12726 }
12727 {
12728 PyThreadState* __tstate = wxPyBeginAllowThreads();
12729 result = (bool)(arg1)->SetCapture(arg2,arg3);
12730
12731 wxPyEndAllowThreads(__tstate);
12732 if (PyErr_Occurred()) SWIG_fail;
12733 }
12734 {
12735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12736 }
12737 return resultobj;
12738 fail:
12739 return NULL;
12740 }
12741
12742
12743 static PyObject *_wrap_Joystick_ReleaseCapture(PyObject *, PyObject *args, PyObject *kwargs) {
12744 PyObject *resultobj;
12745 wxJoystick *arg1 = (wxJoystick *) 0 ;
12746 bool result;
12747 PyObject * obj0 = 0 ;
12748 char *kwnames[] = {
12749 (char *) "self", NULL
12750 };
12751
12752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Joystick_ReleaseCapture",kwnames,&obj0)) goto fail;
12753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystick, SWIG_POINTER_EXCEPTION | 0);
12754 if (SWIG_arg_fail(1)) SWIG_fail;
12755 {
12756 PyThreadState* __tstate = wxPyBeginAllowThreads();
12757 result = (bool)(arg1)->ReleaseCapture();
12758
12759 wxPyEndAllowThreads(__tstate);
12760 if (PyErr_Occurred()) SWIG_fail;
12761 }
12762 {
12763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12764 }
12765 return resultobj;
12766 fail:
12767 return NULL;
12768 }
12769
12770
12771 static PyObject * Joystick_swigregister(PyObject *, PyObject *args) {
12772 PyObject *obj;
12773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
12774 SWIG_TypeClientData(SWIGTYPE_p_wxJoystick, obj);
12775 Py_INCREF(obj);
12776 return Py_BuildValue((char *)"");
12777 }
12778 static PyObject *_wrap_new_JoystickEvent(PyObject *, PyObject *args, PyObject *kwargs) {
12779 PyObject *resultobj;
12780 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
12781 int arg2 = (int) 0 ;
12782 int arg3 = (int) wxJOYSTICK1 ;
12783 int arg4 = (int) 0 ;
12784 wxJoystickEvent *result;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 PyObject * obj2 = 0 ;
12788 PyObject * obj3 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "type",(char *) "state",(char *) "joystick",(char *) "change", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_JoystickEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12794 if (obj0) {
12795 {
12796 arg1 = (wxEventType)(SWIG_As_int(obj0));
12797 if (SWIG_arg_fail(1)) SWIG_fail;
12798 }
12799 }
12800 if (obj1) {
12801 {
12802 arg2 = (int)(SWIG_As_int(obj1));
12803 if (SWIG_arg_fail(2)) SWIG_fail;
12804 }
12805 }
12806 if (obj2) {
12807 {
12808 arg3 = (int)(SWIG_As_int(obj2));
12809 if (SWIG_arg_fail(3)) SWIG_fail;
12810 }
12811 }
12812 if (obj3) {
12813 {
12814 arg4 = (int)(SWIG_As_int(obj3));
12815 if (SWIG_arg_fail(4)) SWIG_fail;
12816 }
12817 }
12818 {
12819 PyThreadState* __tstate = wxPyBeginAllowThreads();
12820 result = (wxJoystickEvent *)new wxJoystickEvent(arg1,arg2,arg3,arg4);
12821
12822 wxPyEndAllowThreads(__tstate);
12823 if (PyErr_Occurred()) SWIG_fail;
12824 }
12825 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJoystickEvent, 1);
12826 return resultobj;
12827 fail:
12828 return NULL;
12829 }
12830
12831
12832 static PyObject *_wrap_JoystickEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12833 PyObject *resultobj;
12834 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12835 wxPoint result;
12836 PyObject * obj0 = 0 ;
12837 char *kwnames[] = {
12838 (char *) "self", NULL
12839 };
12840
12841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetPosition",kwnames,&obj0)) goto fail;
12842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12843 if (SWIG_arg_fail(1)) SWIG_fail;
12844 {
12845 PyThreadState* __tstate = wxPyBeginAllowThreads();
12846 result = ((wxJoystickEvent const *)arg1)->GetPosition();
12847
12848 wxPyEndAllowThreads(__tstate);
12849 if (PyErr_Occurred()) SWIG_fail;
12850 }
12851 {
12852 wxPoint * resultptr;
12853 resultptr = new wxPoint((wxPoint &)(result));
12854 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
12855 }
12856 return resultobj;
12857 fail:
12858 return NULL;
12859 }
12860
12861
12862 static PyObject *_wrap_JoystickEvent_GetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
12863 PyObject *resultobj;
12864 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12865 int result;
12866 PyObject * obj0 = 0 ;
12867 char *kwnames[] = {
12868 (char *) "self", NULL
12869 };
12870
12871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetZPosition",kwnames,&obj0)) goto fail;
12872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12873 if (SWIG_arg_fail(1)) SWIG_fail;
12874 {
12875 PyThreadState* __tstate = wxPyBeginAllowThreads();
12876 result = (int)((wxJoystickEvent const *)arg1)->GetZPosition();
12877
12878 wxPyEndAllowThreads(__tstate);
12879 if (PyErr_Occurred()) SWIG_fail;
12880 }
12881 {
12882 resultobj = SWIG_From_int((int)(result));
12883 }
12884 return resultobj;
12885 fail:
12886 return NULL;
12887 }
12888
12889
12890 static PyObject *_wrap_JoystickEvent_GetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
12891 PyObject *resultobj;
12892 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12893 int result;
12894 PyObject * obj0 = 0 ;
12895 char *kwnames[] = {
12896 (char *) "self", NULL
12897 };
12898
12899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonState",kwnames,&obj0)) goto fail;
12900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12901 if (SWIG_arg_fail(1)) SWIG_fail;
12902 {
12903 PyThreadState* __tstate = wxPyBeginAllowThreads();
12904 result = (int)((wxJoystickEvent const *)arg1)->GetButtonState();
12905
12906 wxPyEndAllowThreads(__tstate);
12907 if (PyErr_Occurred()) SWIG_fail;
12908 }
12909 {
12910 resultobj = SWIG_From_int((int)(result));
12911 }
12912 return resultobj;
12913 fail:
12914 return NULL;
12915 }
12916
12917
12918 static PyObject *_wrap_JoystickEvent_GetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
12919 PyObject *resultobj;
12920 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12921 int result;
12922 PyObject * obj0 = 0 ;
12923 char *kwnames[] = {
12924 (char *) "self", NULL
12925 };
12926
12927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetButtonChange",kwnames,&obj0)) goto fail;
12928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12929 if (SWIG_arg_fail(1)) SWIG_fail;
12930 {
12931 PyThreadState* __tstate = wxPyBeginAllowThreads();
12932 result = (int)((wxJoystickEvent const *)arg1)->GetButtonChange();
12933
12934 wxPyEndAllowThreads(__tstate);
12935 if (PyErr_Occurred()) SWIG_fail;
12936 }
12937 {
12938 resultobj = SWIG_From_int((int)(result));
12939 }
12940 return resultobj;
12941 fail:
12942 return NULL;
12943 }
12944
12945
12946 static PyObject *_wrap_JoystickEvent_GetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj;
12948 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12949 int result;
12950 PyObject * obj0 = 0 ;
12951 char *kwnames[] = {
12952 (char *) "self", NULL
12953 };
12954
12955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_GetJoystick",kwnames,&obj0)) goto fail;
12956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12957 if (SWIG_arg_fail(1)) SWIG_fail;
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (int)((wxJoystickEvent const *)arg1)->GetJoystick();
12961
12962 wxPyEndAllowThreads(__tstate);
12963 if (PyErr_Occurred()) SWIG_fail;
12964 }
12965 {
12966 resultobj = SWIG_From_int((int)(result));
12967 }
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 static PyObject *_wrap_JoystickEvent_SetJoystick(PyObject *, PyObject *args, PyObject *kwargs) {
12975 PyObject *resultobj;
12976 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
12977 int arg2 ;
12978 PyObject * obj0 = 0 ;
12979 PyObject * obj1 = 0 ;
12980 char *kwnames[] = {
12981 (char *) "self",(char *) "stick", NULL
12982 };
12983
12984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetJoystick",kwnames,&obj0,&obj1)) goto fail;
12985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
12986 if (SWIG_arg_fail(1)) SWIG_fail;
12987 {
12988 arg2 = (int)(SWIG_As_int(obj1));
12989 if (SWIG_arg_fail(2)) SWIG_fail;
12990 }
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 (arg1)->SetJoystick(arg2);
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 Py_INCREF(Py_None); resultobj = Py_None;
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_JoystickEvent_SetButtonState(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13008 int arg2 ;
13009 PyObject * obj0 = 0 ;
13010 PyObject * obj1 = 0 ;
13011 char *kwnames[] = {
13012 (char *) "self",(char *) "state", NULL
13013 };
13014
13015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonState",kwnames,&obj0,&obj1)) goto fail;
13016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13017 if (SWIG_arg_fail(1)) SWIG_fail;
13018 {
13019 arg2 = (int)(SWIG_As_int(obj1));
13020 if (SWIG_arg_fail(2)) SWIG_fail;
13021 }
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 (arg1)->SetButtonState(arg2);
13025
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 Py_INCREF(Py_None); resultobj = Py_None;
13030 return resultobj;
13031 fail:
13032 return NULL;
13033 }
13034
13035
13036 static PyObject *_wrap_JoystickEvent_SetButtonChange(PyObject *, PyObject *args, PyObject *kwargs) {
13037 PyObject *resultobj;
13038 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13039 int arg2 ;
13040 PyObject * obj0 = 0 ;
13041 PyObject * obj1 = 0 ;
13042 char *kwnames[] = {
13043 (char *) "self",(char *) "change", NULL
13044 };
13045
13046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetButtonChange",kwnames,&obj0,&obj1)) goto fail;
13047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13048 if (SWIG_arg_fail(1)) SWIG_fail;
13049 {
13050 arg2 = (int)(SWIG_As_int(obj1));
13051 if (SWIG_arg_fail(2)) SWIG_fail;
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 (arg1)->SetButtonChange(arg2);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 Py_INCREF(Py_None); resultobj = Py_None;
13061 return resultobj;
13062 fail:
13063 return NULL;
13064 }
13065
13066
13067 static PyObject *_wrap_JoystickEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13068 PyObject *resultobj;
13069 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13070 wxPoint *arg2 = 0 ;
13071 wxPoint temp2 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 char *kwnames[] = {
13075 (char *) "self",(char *) "pos", NULL
13076 };
13077
13078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
13079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13080 if (SWIG_arg_fail(1)) SWIG_fail;
13081 {
13082 arg2 = &temp2;
13083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
13084 }
13085 {
13086 PyThreadState* __tstate = wxPyBeginAllowThreads();
13087 (arg1)->SetPosition((wxPoint const &)*arg2);
13088
13089 wxPyEndAllowThreads(__tstate);
13090 if (PyErr_Occurred()) SWIG_fail;
13091 }
13092 Py_INCREF(Py_None); resultobj = Py_None;
13093 return resultobj;
13094 fail:
13095 return NULL;
13096 }
13097
13098
13099 static PyObject *_wrap_JoystickEvent_SetZPosition(PyObject *, PyObject *args, PyObject *kwargs) {
13100 PyObject *resultobj;
13101 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13102 int arg2 ;
13103 PyObject * obj0 = 0 ;
13104 PyObject * obj1 = 0 ;
13105 char *kwnames[] = {
13106 (char *) "self",(char *) "zPos", NULL
13107 };
13108
13109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:JoystickEvent_SetZPosition",kwnames,&obj0,&obj1)) goto fail;
13110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13111 if (SWIG_arg_fail(1)) SWIG_fail;
13112 {
13113 arg2 = (int)(SWIG_As_int(obj1));
13114 if (SWIG_arg_fail(2)) SWIG_fail;
13115 }
13116 {
13117 PyThreadState* __tstate = wxPyBeginAllowThreads();
13118 (arg1)->SetZPosition(arg2);
13119
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 Py_INCREF(Py_None); resultobj = Py_None;
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 static PyObject *_wrap_JoystickEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
13131 PyObject *resultobj;
13132 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13133 bool result;
13134 PyObject * obj0 = 0 ;
13135 char *kwnames[] = {
13136 (char *) "self", NULL
13137 };
13138
13139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsButton",kwnames,&obj0)) goto fail;
13140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13141 if (SWIG_arg_fail(1)) SWIG_fail;
13142 {
13143 PyThreadState* __tstate = wxPyBeginAllowThreads();
13144 result = (bool)((wxJoystickEvent const *)arg1)->IsButton();
13145
13146 wxPyEndAllowThreads(__tstate);
13147 if (PyErr_Occurred()) SWIG_fail;
13148 }
13149 {
13150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13151 }
13152 return resultobj;
13153 fail:
13154 return NULL;
13155 }
13156
13157
13158 static PyObject *_wrap_JoystickEvent_IsMove(PyObject *, PyObject *args, PyObject *kwargs) {
13159 PyObject *resultobj;
13160 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13161 bool result;
13162 PyObject * obj0 = 0 ;
13163 char *kwnames[] = {
13164 (char *) "self", NULL
13165 };
13166
13167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsMove",kwnames,&obj0)) goto fail;
13168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13169 if (SWIG_arg_fail(1)) SWIG_fail;
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (bool)((wxJoystickEvent const *)arg1)->IsMove();
13173
13174 wxPyEndAllowThreads(__tstate);
13175 if (PyErr_Occurred()) SWIG_fail;
13176 }
13177 {
13178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13179 }
13180 return resultobj;
13181 fail:
13182 return NULL;
13183 }
13184
13185
13186 static PyObject *_wrap_JoystickEvent_IsZMove(PyObject *, PyObject *args, PyObject *kwargs) {
13187 PyObject *resultobj;
13188 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13189 bool result;
13190 PyObject * obj0 = 0 ;
13191 char *kwnames[] = {
13192 (char *) "self", NULL
13193 };
13194
13195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:JoystickEvent_IsZMove",kwnames,&obj0)) goto fail;
13196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13197 if (SWIG_arg_fail(1)) SWIG_fail;
13198 {
13199 PyThreadState* __tstate = wxPyBeginAllowThreads();
13200 result = (bool)((wxJoystickEvent const *)arg1)->IsZMove();
13201
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13207 }
13208 return resultobj;
13209 fail:
13210 return NULL;
13211 }
13212
13213
13214 static PyObject *_wrap_JoystickEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
13215 PyObject *resultobj;
13216 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13217 int arg2 = (int) wxJOY_BUTTON_ANY ;
13218 bool result;
13219 PyObject * obj0 = 0 ;
13220 PyObject * obj1 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self",(char *) "but", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 if (obj1) {
13229 {
13230 arg2 = (int)(SWIG_As_int(obj1));
13231 if (SWIG_arg_fail(2)) SWIG_fail;
13232 }
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 result = (bool)((wxJoystickEvent const *)arg1)->ButtonDown(arg2);
13237
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 {
13242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13243 }
13244 return resultobj;
13245 fail:
13246 return NULL;
13247 }
13248
13249
13250 static PyObject *_wrap_JoystickEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
13251 PyObject *resultobj;
13252 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13253 int arg2 = (int) wxJOY_BUTTON_ANY ;
13254 bool result;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 char *kwnames[] = {
13258 (char *) "self",(char *) "but", NULL
13259 };
13260
13261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
13262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13263 if (SWIG_arg_fail(1)) SWIG_fail;
13264 if (obj1) {
13265 {
13266 arg2 = (int)(SWIG_As_int(obj1));
13267 if (SWIG_arg_fail(2)) SWIG_fail;
13268 }
13269 }
13270 {
13271 PyThreadState* __tstate = wxPyBeginAllowThreads();
13272 result = (bool)((wxJoystickEvent const *)arg1)->ButtonUp(arg2);
13273
13274 wxPyEndAllowThreads(__tstate);
13275 if (PyErr_Occurred()) SWIG_fail;
13276 }
13277 {
13278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13279 }
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 static PyObject *_wrap_JoystickEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj;
13288 wxJoystickEvent *arg1 = (wxJoystickEvent *) 0 ;
13289 int arg2 = (int) wxJOY_BUTTON_ANY ;
13290 bool result;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "but", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:JoystickEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxJoystickEvent, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 if (obj1) {
13301 {
13302 arg2 = (int)(SWIG_As_int(obj1));
13303 if (SWIG_arg_fail(2)) SWIG_fail;
13304 }
13305 }
13306 {
13307 PyThreadState* __tstate = wxPyBeginAllowThreads();
13308 result = (bool)((wxJoystickEvent const *)arg1)->ButtonIsDown(arg2);
13309
13310 wxPyEndAllowThreads(__tstate);
13311 if (PyErr_Occurred()) SWIG_fail;
13312 }
13313 {
13314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13315 }
13316 return resultobj;
13317 fail:
13318 return NULL;
13319 }
13320
13321
13322 static PyObject * JoystickEvent_swigregister(PyObject *, PyObject *args) {
13323 PyObject *obj;
13324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13325 SWIG_TypeClientData(SWIGTYPE_p_wxJoystickEvent, obj);
13326 Py_INCREF(obj);
13327 return Py_BuildValue((char *)"");
13328 }
13329 static PyObject *_wrap_new_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj;
13331 wxString const &arg1_defvalue = wxPyEmptyString ;
13332 wxString *arg1 = (wxString *) &arg1_defvalue ;
13333 wxSound *result;
13334 bool temp1 = false ;
13335 PyObject * obj0 = 0 ;
13336 char *kwnames[] = {
13337 (char *) "fileName", NULL
13338 };
13339
13340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Sound",kwnames,&obj0)) goto fail;
13341 if (obj0) {
13342 {
13343 arg1 = wxString_in_helper(obj0);
13344 if (arg1 == NULL) SWIG_fail;
13345 temp1 = true;
13346 }
13347 }
13348 {
13349 if (!wxPyCheckForApp()) SWIG_fail;
13350 PyThreadState* __tstate = wxPyBeginAllowThreads();
13351 result = (wxSound *)new_wxSound((wxString const &)*arg1);
13352
13353 wxPyEndAllowThreads(__tstate);
13354 if (PyErr_Occurred()) SWIG_fail;
13355 }
13356 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13357 {
13358 if (temp1)
13359 delete arg1;
13360 }
13361 return resultobj;
13362 fail:
13363 {
13364 if (temp1)
13365 delete arg1;
13366 }
13367 return NULL;
13368 }
13369
13370
13371 static PyObject *_wrap_new_SoundFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13372 PyObject *resultobj;
13373 PyObject *arg1 = (PyObject *) 0 ;
13374 wxSound *result;
13375 PyObject * obj0 = 0 ;
13376 char *kwnames[] = {
13377 (char *) "data", NULL
13378 };
13379
13380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_SoundFromData",kwnames,&obj0)) goto fail;
13381 arg1 = obj0;
13382 {
13383 if (!wxPyCheckForApp()) SWIG_fail;
13384 PyThreadState* __tstate = wxPyBeginAllowThreads();
13385 result = (wxSound *)new_wxSound(arg1);
13386
13387 wxPyEndAllowThreads(__tstate);
13388 if (PyErr_Occurred()) SWIG_fail;
13389 }
13390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSound, 1);
13391 return resultobj;
13392 fail:
13393 return NULL;
13394 }
13395
13396
13397 static PyObject *_wrap_delete_Sound(PyObject *, PyObject *args, PyObject *kwargs) {
13398 PyObject *resultobj;
13399 wxSound *arg1 = (wxSound *) 0 ;
13400 PyObject * obj0 = 0 ;
13401 char *kwnames[] = {
13402 (char *) "self", NULL
13403 };
13404
13405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sound",kwnames,&obj0)) goto fail;
13406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13407 if (SWIG_arg_fail(1)) SWIG_fail;
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 delete arg1;
13411
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 Py_INCREF(Py_None); resultobj = Py_None;
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 static PyObject *_wrap_Sound_Create(PyObject *, PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj;
13424 wxSound *arg1 = (wxSound *) 0 ;
13425 wxString *arg2 = 0 ;
13426 bool result;
13427 bool temp2 = false ;
13428 PyObject * obj0 = 0 ;
13429 PyObject * obj1 = 0 ;
13430 char *kwnames[] = {
13431 (char *) "self",(char *) "fileName", NULL
13432 };
13433
13434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_Create",kwnames,&obj0,&obj1)) goto fail;
13435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13436 if (SWIG_arg_fail(1)) SWIG_fail;
13437 {
13438 arg2 = wxString_in_helper(obj1);
13439 if (arg2 == NULL) SWIG_fail;
13440 temp2 = true;
13441 }
13442 {
13443 PyThreadState* __tstate = wxPyBeginAllowThreads();
13444 result = (bool)(arg1)->Create((wxString const &)*arg2);
13445
13446 wxPyEndAllowThreads(__tstate);
13447 if (PyErr_Occurred()) SWIG_fail;
13448 }
13449 {
13450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13451 }
13452 {
13453 if (temp2)
13454 delete arg2;
13455 }
13456 return resultobj;
13457 fail:
13458 {
13459 if (temp2)
13460 delete arg2;
13461 }
13462 return NULL;
13463 }
13464
13465
13466 static PyObject *_wrap_Sound_CreateFromData(PyObject *, PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj;
13468 wxSound *arg1 = (wxSound *) 0 ;
13469 PyObject *arg2 = (PyObject *) 0 ;
13470 bool result;
13471 PyObject * obj0 = 0 ;
13472 PyObject * obj1 = 0 ;
13473 char *kwnames[] = {
13474 (char *) "self",(char *) "data", NULL
13475 };
13476
13477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sound_CreateFromData",kwnames,&obj0,&obj1)) goto fail;
13478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13479 if (SWIG_arg_fail(1)) SWIG_fail;
13480 arg2 = obj1;
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = (bool)wxSound_CreateFromData(arg1,arg2);
13484
13485 wxPyEndAllowThreads(__tstate);
13486 if (PyErr_Occurred()) SWIG_fail;
13487 }
13488 {
13489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13490 }
13491 return resultobj;
13492 fail:
13493 return NULL;
13494 }
13495
13496
13497 static PyObject *_wrap_Sound_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
13498 PyObject *resultobj;
13499 wxSound *arg1 = (wxSound *) 0 ;
13500 bool result;
13501 PyObject * obj0 = 0 ;
13502 char *kwnames[] = {
13503 (char *) "self", NULL
13504 };
13505
13506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sound_IsOk",kwnames,&obj0)) goto fail;
13507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13508 if (SWIG_arg_fail(1)) SWIG_fail;
13509 {
13510 PyThreadState* __tstate = wxPyBeginAllowThreads();
13511 result = (bool)(arg1)->IsOk();
13512
13513 wxPyEndAllowThreads(__tstate);
13514 if (PyErr_Occurred()) SWIG_fail;
13515 }
13516 {
13517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13518 }
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 static PyObject *_wrap_Sound_Play(PyObject *, PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj;
13527 wxSound *arg1 = (wxSound *) 0 ;
13528 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13529 bool result;
13530 PyObject * obj0 = 0 ;
13531 PyObject * obj1 = 0 ;
13532 char *kwnames[] = {
13533 (char *) "self",(char *) "flags", NULL
13534 };
13535
13536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_Play",kwnames,&obj0,&obj1)) goto fail;
13537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSound, SWIG_POINTER_EXCEPTION | 0);
13538 if (SWIG_arg_fail(1)) SWIG_fail;
13539 if (obj1) {
13540 {
13541 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13542 if (SWIG_arg_fail(2)) SWIG_fail;
13543 }
13544 }
13545 {
13546 if (!wxPyCheckForApp()) SWIG_fail;
13547 PyThreadState* __tstate = wxPyBeginAllowThreads();
13548 result = (bool)((wxSound const *)arg1)->Play(arg2);
13549
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 {
13554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13555 }
13556 return resultobj;
13557 fail:
13558 return NULL;
13559 }
13560
13561
13562 static PyObject *_wrap_Sound_PlaySound(PyObject *, PyObject *args, PyObject *kwargs) {
13563 PyObject *resultobj;
13564 wxString *arg1 = 0 ;
13565 unsigned int arg2 = (unsigned int) wxSOUND_ASYNC ;
13566 bool result;
13567 bool temp1 = false ;
13568 PyObject * obj0 = 0 ;
13569 PyObject * obj1 = 0 ;
13570 char *kwnames[] = {
13571 (char *) "filename",(char *) "flags", NULL
13572 };
13573
13574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sound_PlaySound",kwnames,&obj0,&obj1)) goto fail;
13575 {
13576 arg1 = wxString_in_helper(obj0);
13577 if (arg1 == NULL) SWIG_fail;
13578 temp1 = true;
13579 }
13580 if (obj1) {
13581 {
13582 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
13583 if (SWIG_arg_fail(2)) SWIG_fail;
13584 }
13585 }
13586 {
13587 if (!wxPyCheckForApp()) SWIG_fail;
13588 PyThreadState* __tstate = wxPyBeginAllowThreads();
13589 result = (bool)wxSound::Play((wxString const &)*arg1,arg2);
13590
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 {
13595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13596 }
13597 {
13598 if (temp1)
13599 delete arg1;
13600 }
13601 return resultobj;
13602 fail:
13603 {
13604 if (temp1)
13605 delete arg1;
13606 }
13607 return NULL;
13608 }
13609
13610
13611 static PyObject *_wrap_Sound_Stop(PyObject *, PyObject *args, PyObject *kwargs) {
13612 PyObject *resultobj;
13613 char *kwnames[] = {
13614 NULL
13615 };
13616
13617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Sound_Stop",kwnames)) goto fail;
13618 {
13619 if (!wxPyCheckForApp()) SWIG_fail;
13620 PyThreadState* __tstate = wxPyBeginAllowThreads();
13621 wxSound::Stop();
13622
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 Py_INCREF(Py_None); resultobj = Py_None;
13627 return resultobj;
13628 fail:
13629 return NULL;
13630 }
13631
13632
13633 static PyObject * Sound_swigregister(PyObject *, PyObject *args) {
13634 PyObject *obj;
13635 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13636 SWIG_TypeClientData(SWIGTYPE_p_wxSound, obj);
13637 Py_INCREF(obj);
13638 return Py_BuildValue((char *)"");
13639 }
13640 static PyObject *_wrap_new_FileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj;
13642 wxString *arg1 = 0 ;
13643 wxString *arg2 = 0 ;
13644 wxString *arg3 = 0 ;
13645 wxString *arg4 = 0 ;
13646 wxFileTypeInfo *result;
13647 bool temp1 = false ;
13648 bool temp2 = false ;
13649 bool temp3 = false ;
13650 bool temp4 = false ;
13651 PyObject * obj0 = 0 ;
13652 PyObject * obj1 = 0 ;
13653 PyObject * obj2 = 0 ;
13654 PyObject * obj3 = 0 ;
13655 char *kwnames[] = {
13656 (char *) "mimeType",(char *) "openCmd",(char *) "printCmd",(char *) "desc", NULL
13657 };
13658
13659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_FileTypeInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13660 {
13661 arg1 = wxString_in_helper(obj0);
13662 if (arg1 == NULL) SWIG_fail;
13663 temp1 = true;
13664 }
13665 {
13666 arg2 = wxString_in_helper(obj1);
13667 if (arg2 == NULL) SWIG_fail;
13668 temp2 = true;
13669 }
13670 {
13671 arg3 = wxString_in_helper(obj2);
13672 if (arg3 == NULL) SWIG_fail;
13673 temp3 = true;
13674 }
13675 {
13676 arg4 = wxString_in_helper(obj3);
13677 if (arg4 == NULL) SWIG_fail;
13678 temp4 = true;
13679 }
13680 {
13681 PyThreadState* __tstate = wxPyBeginAllowThreads();
13682 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4);
13683
13684 wxPyEndAllowThreads(__tstate);
13685 if (PyErr_Occurred()) SWIG_fail;
13686 }
13687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13688 {
13689 if (temp1)
13690 delete arg1;
13691 }
13692 {
13693 if (temp2)
13694 delete arg2;
13695 }
13696 {
13697 if (temp3)
13698 delete arg3;
13699 }
13700 {
13701 if (temp4)
13702 delete arg4;
13703 }
13704 return resultobj;
13705 fail:
13706 {
13707 if (temp1)
13708 delete arg1;
13709 }
13710 {
13711 if (temp2)
13712 delete arg2;
13713 }
13714 {
13715 if (temp3)
13716 delete arg3;
13717 }
13718 {
13719 if (temp4)
13720 delete arg4;
13721 }
13722 return NULL;
13723 }
13724
13725
13726 static PyObject *_wrap_new_FileTypeInfoSequence(PyObject *, PyObject *args, PyObject *kwargs) {
13727 PyObject *resultobj;
13728 wxArrayString *arg1 = 0 ;
13729 wxFileTypeInfo *result;
13730 bool temp1 = false ;
13731 PyObject * obj0 = 0 ;
13732 char *kwnames[] = {
13733 (char *) "sArray", NULL
13734 };
13735
13736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileTypeInfoSequence",kwnames,&obj0)) goto fail;
13737 {
13738 if (! PySequence_Check(obj0)) {
13739 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
13740 SWIG_fail;
13741 }
13742 arg1 = new wxArrayString;
13743 temp1 = true;
13744 int i, len=PySequence_Length(obj0);
13745 for (i=0; i<len; i++) {
13746 PyObject* item = PySequence_GetItem(obj0, i);
13747 #if wxUSE_UNICODE
13748 PyObject* str = PyObject_Unicode(item);
13749 #else
13750 PyObject* str = PyObject_Str(item);
13751 #endif
13752 if (PyErr_Occurred()) SWIG_fail;
13753 arg1->Add(Py2wxString(str));
13754 Py_DECREF(item);
13755 Py_DECREF(str);
13756 }
13757 }
13758 {
13759 PyThreadState* __tstate = wxPyBeginAllowThreads();
13760 result = (wxFileTypeInfo *)new wxFileTypeInfo((wxArrayString const &)*arg1);
13761
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13766 {
13767 if (temp1) delete arg1;
13768 }
13769 return resultobj;
13770 fail:
13771 {
13772 if (temp1) delete arg1;
13773 }
13774 return NULL;
13775 }
13776
13777
13778 static PyObject *_wrap_new_NullFileTypeInfo(PyObject *, PyObject *args, PyObject *kwargs) {
13779 PyObject *resultobj;
13780 wxFileTypeInfo *result;
13781 char *kwnames[] = {
13782 NULL
13783 };
13784
13785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NullFileTypeInfo",kwnames)) goto fail;
13786 {
13787 PyThreadState* __tstate = wxPyBeginAllowThreads();
13788 result = (wxFileTypeInfo *)new wxFileTypeInfo();
13789
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileTypeInfo, 1);
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 static PyObject *_wrap_FileTypeInfo_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
13801 PyObject *resultobj;
13802 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13803 bool result;
13804 PyObject * obj0 = 0 ;
13805 char *kwnames[] = {
13806 (char *) "self", NULL
13807 };
13808
13809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_IsValid",kwnames,&obj0)) goto fail;
13810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13811 if (SWIG_arg_fail(1)) SWIG_fail;
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (bool)((wxFileTypeInfo const *)arg1)->IsValid();
13815
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 {
13820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13821 }
13822 return resultobj;
13823 fail:
13824 return NULL;
13825 }
13826
13827
13828 static PyObject *_wrap_FileTypeInfo_SetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
13829 PyObject *resultobj;
13830 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13831 wxString *arg2 = 0 ;
13832 int arg3 = (int) 0 ;
13833 bool temp2 = false ;
13834 PyObject * obj0 = 0 ;
13835 PyObject * obj1 = 0 ;
13836 PyObject * obj2 = 0 ;
13837 char *kwnames[] = {
13838 (char *) "self",(char *) "iconFile",(char *) "iconIndex", NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileTypeInfo_SetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
13842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13843 if (SWIG_arg_fail(1)) SWIG_fail;
13844 {
13845 arg2 = wxString_in_helper(obj1);
13846 if (arg2 == NULL) SWIG_fail;
13847 temp2 = true;
13848 }
13849 if (obj2) {
13850 {
13851 arg3 = (int)(SWIG_As_int(obj2));
13852 if (SWIG_arg_fail(3)) SWIG_fail;
13853 }
13854 }
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 (arg1)->SetIcon((wxString const &)*arg2,arg3);
13858
13859 wxPyEndAllowThreads(__tstate);
13860 if (PyErr_Occurred()) SWIG_fail;
13861 }
13862 Py_INCREF(Py_None); resultobj = Py_None;
13863 {
13864 if (temp2)
13865 delete arg2;
13866 }
13867 return resultobj;
13868 fail:
13869 {
13870 if (temp2)
13871 delete arg2;
13872 }
13873 return NULL;
13874 }
13875
13876
13877 static PyObject *_wrap_FileTypeInfo_SetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
13878 PyObject *resultobj;
13879 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13880 wxString *arg2 = 0 ;
13881 bool temp2 = false ;
13882 PyObject * obj0 = 0 ;
13883 PyObject * obj1 = 0 ;
13884 char *kwnames[] = {
13885 (char *) "self",(char *) "shortDesc", NULL
13886 };
13887
13888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileTypeInfo_SetShortDesc",kwnames,&obj0,&obj1)) goto fail;
13889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13890 if (SWIG_arg_fail(1)) SWIG_fail;
13891 {
13892 arg2 = wxString_in_helper(obj1);
13893 if (arg2 == NULL) SWIG_fail;
13894 temp2 = true;
13895 }
13896 {
13897 PyThreadState* __tstate = wxPyBeginAllowThreads();
13898 (arg1)->SetShortDesc((wxString const &)*arg2);
13899
13900 wxPyEndAllowThreads(__tstate);
13901 if (PyErr_Occurred()) SWIG_fail;
13902 }
13903 Py_INCREF(Py_None); resultobj = Py_None;
13904 {
13905 if (temp2)
13906 delete arg2;
13907 }
13908 return resultobj;
13909 fail:
13910 {
13911 if (temp2)
13912 delete arg2;
13913 }
13914 return NULL;
13915 }
13916
13917
13918 static PyObject *_wrap_FileTypeInfo_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
13919 PyObject *resultobj;
13920 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13921 wxString *result;
13922 PyObject * obj0 = 0 ;
13923 char *kwnames[] = {
13924 (char *) "self", NULL
13925 };
13926
13927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetMimeType",kwnames,&obj0)) goto fail;
13928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13929 if (SWIG_arg_fail(1)) SWIG_fail;
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 {
13933 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetMimeType();
13934 result = (wxString *) &_result_ref;
13935 }
13936
13937 wxPyEndAllowThreads(__tstate);
13938 if (PyErr_Occurred()) SWIG_fail;
13939 }
13940 {
13941 #if wxUSE_UNICODE
13942 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13943 #else
13944 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13945 #endif
13946 }
13947 return resultobj;
13948 fail:
13949 return NULL;
13950 }
13951
13952
13953 static PyObject *_wrap_FileTypeInfo_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13954 PyObject *resultobj;
13955 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13956 wxString *result;
13957 PyObject * obj0 = 0 ;
13958 char *kwnames[] = {
13959 (char *) "self", NULL
13960 };
13961
13962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetOpenCommand",kwnames,&obj0)) goto fail;
13963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13964 if (SWIG_arg_fail(1)) SWIG_fail;
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 {
13968 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetOpenCommand();
13969 result = (wxString *) &_result_ref;
13970 }
13971
13972 wxPyEndAllowThreads(__tstate);
13973 if (PyErr_Occurred()) SWIG_fail;
13974 }
13975 {
13976 #if wxUSE_UNICODE
13977 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13978 #else
13979 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13980 #endif
13981 }
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 static PyObject *_wrap_FileTypeInfo_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj;
13990 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
13991 wxString *result;
13992 PyObject * obj0 = 0 ;
13993 char *kwnames[] = {
13994 (char *) "self", NULL
13995 };
13996
13997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetPrintCommand",kwnames,&obj0)) goto fail;
13998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
13999 if (SWIG_arg_fail(1)) SWIG_fail;
14000 {
14001 PyThreadState* __tstate = wxPyBeginAllowThreads();
14002 {
14003 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetPrintCommand();
14004 result = (wxString *) &_result_ref;
14005 }
14006
14007 wxPyEndAllowThreads(__tstate);
14008 if (PyErr_Occurred()) SWIG_fail;
14009 }
14010 {
14011 #if wxUSE_UNICODE
14012 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14013 #else
14014 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14015 #endif
14016 }
14017 return resultobj;
14018 fail:
14019 return NULL;
14020 }
14021
14022
14023 static PyObject *_wrap_FileTypeInfo_GetShortDesc(PyObject *, PyObject *args, PyObject *kwargs) {
14024 PyObject *resultobj;
14025 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14026 wxString *result;
14027 PyObject * obj0 = 0 ;
14028 char *kwnames[] = {
14029 (char *) "self", NULL
14030 };
14031
14032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetShortDesc",kwnames,&obj0)) goto fail;
14033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14034 if (SWIG_arg_fail(1)) SWIG_fail;
14035 {
14036 PyThreadState* __tstate = wxPyBeginAllowThreads();
14037 {
14038 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetShortDesc();
14039 result = (wxString *) &_result_ref;
14040 }
14041
14042 wxPyEndAllowThreads(__tstate);
14043 if (PyErr_Occurred()) SWIG_fail;
14044 }
14045 {
14046 #if wxUSE_UNICODE
14047 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14048 #else
14049 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14050 #endif
14051 }
14052 return resultobj;
14053 fail:
14054 return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_FileTypeInfo_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14059 PyObject *resultobj;
14060 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14061 wxString *result;
14062 PyObject * obj0 = 0 ;
14063 char *kwnames[] = {
14064 (char *) "self", NULL
14065 };
14066
14067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetDescription",kwnames,&obj0)) goto fail;
14068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14069 if (SWIG_arg_fail(1)) SWIG_fail;
14070 {
14071 PyThreadState* __tstate = wxPyBeginAllowThreads();
14072 {
14073 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetDescription();
14074 result = (wxString *) &_result_ref;
14075 }
14076
14077 wxPyEndAllowThreads(__tstate);
14078 if (PyErr_Occurred()) SWIG_fail;
14079 }
14080 {
14081 #if wxUSE_UNICODE
14082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14083 #else
14084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14085 #endif
14086 }
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 static PyObject *_wrap_FileTypeInfo_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj;
14095 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14096 wxArrayString *result;
14097 PyObject * obj0 = 0 ;
14098 char *kwnames[] = {
14099 (char *) "self", NULL
14100 };
14101
14102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensions",kwnames,&obj0)) goto fail;
14103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14104 if (SWIG_arg_fail(1)) SWIG_fail;
14105 {
14106 PyThreadState* __tstate = wxPyBeginAllowThreads();
14107 {
14108 wxArrayString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetExtensions();
14109 result = (wxArrayString *) &_result_ref;
14110 }
14111
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 {
14116 resultobj = wxArrayString2PyList_helper(*result);
14117 }
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_FileTypeInfo_GetExtensionsCount(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14127 int result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetExtensionsCount",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (int)((wxFileTypeInfo const *)arg1)->GetExtensionsCount();
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = SWIG_From_int((int)(result));
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 static PyObject *_wrap_FileTypeInfo_GetIconFile(PyObject *, PyObject *args, PyObject *kwargs) {
14153 PyObject *resultobj;
14154 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14155 wxString *result;
14156 PyObject * obj0 = 0 ;
14157 char *kwnames[] = {
14158 (char *) "self", NULL
14159 };
14160
14161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconFile",kwnames,&obj0)) goto fail;
14162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14163 if (SWIG_arg_fail(1)) SWIG_fail;
14164 {
14165 PyThreadState* __tstate = wxPyBeginAllowThreads();
14166 {
14167 wxString const &_result_ref = ((wxFileTypeInfo const *)arg1)->GetIconFile();
14168 result = (wxString *) &_result_ref;
14169 }
14170
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 {
14175 #if wxUSE_UNICODE
14176 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
14177 #else
14178 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
14179 #endif
14180 }
14181 return resultobj;
14182 fail:
14183 return NULL;
14184 }
14185
14186
14187 static PyObject *_wrap_FileTypeInfo_GetIconIndex(PyObject *, PyObject *args, PyObject *kwargs) {
14188 PyObject *resultobj;
14189 wxFileTypeInfo *arg1 = (wxFileTypeInfo *) 0 ;
14190 int result;
14191 PyObject * obj0 = 0 ;
14192 char *kwnames[] = {
14193 (char *) "self", NULL
14194 };
14195
14196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileTypeInfo_GetIconIndex",kwnames,&obj0)) goto fail;
14197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14198 if (SWIG_arg_fail(1)) SWIG_fail;
14199 {
14200 PyThreadState* __tstate = wxPyBeginAllowThreads();
14201 result = (int)((wxFileTypeInfo const *)arg1)->GetIconIndex();
14202
14203 wxPyEndAllowThreads(__tstate);
14204 if (PyErr_Occurred()) SWIG_fail;
14205 }
14206 {
14207 resultobj = SWIG_From_int((int)(result));
14208 }
14209 return resultobj;
14210 fail:
14211 return NULL;
14212 }
14213
14214
14215 static PyObject * FileTypeInfo_swigregister(PyObject *, PyObject *args) {
14216 PyObject *obj;
14217 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14218 SWIG_TypeClientData(SWIGTYPE_p_wxFileTypeInfo, obj);
14219 Py_INCREF(obj);
14220 return Py_BuildValue((char *)"");
14221 }
14222 static PyObject *_wrap_new_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14223 PyObject *resultobj;
14224 wxFileTypeInfo *arg1 = 0 ;
14225 wxFileType *result;
14226 PyObject * obj0 = 0 ;
14227 char *kwnames[] = {
14228 (char *) "ftInfo", NULL
14229 };
14230
14231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_FileType",kwnames,&obj0)) goto fail;
14232 {
14233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
14234 if (SWIG_arg_fail(1)) SWIG_fail;
14235 if (arg1 == NULL) {
14236 SWIG_null_ref("wxFileTypeInfo");
14237 }
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (wxFileType *)new wxFileType((wxFileTypeInfo const &)*arg1);
14243
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 static PyObject *_wrap_delete_FileType(PyObject *, PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj;
14256 wxFileType *arg1 = (wxFileType *) 0 ;
14257 PyObject * obj0 = 0 ;
14258 char *kwnames[] = {
14259 (char *) "self", NULL
14260 };
14261
14262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileType",kwnames,&obj0)) goto fail;
14263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14264 if (SWIG_arg_fail(1)) SWIG_fail;
14265 {
14266 PyThreadState* __tstate = wxPyBeginAllowThreads();
14267 delete arg1;
14268
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 Py_INCREF(Py_None); resultobj = Py_None;
14273 return resultobj;
14274 fail:
14275 return NULL;
14276 }
14277
14278
14279 static PyObject *_wrap_FileType_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
14280 PyObject *resultobj;
14281 wxFileType *arg1 = (wxFileType *) 0 ;
14282 PyObject *result;
14283 PyObject * obj0 = 0 ;
14284 char *kwnames[] = {
14285 (char *) "self", NULL
14286 };
14287
14288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeType",kwnames,&obj0)) goto fail;
14289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14290 if (SWIG_arg_fail(1)) SWIG_fail;
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (PyObject *)wxFileType_GetMimeType(arg1);
14294
14295 wxPyEndAllowThreads(__tstate);
14296 if (PyErr_Occurred()) SWIG_fail;
14297 }
14298 resultobj = result;
14299 return resultobj;
14300 fail:
14301 return NULL;
14302 }
14303
14304
14305 static PyObject *_wrap_FileType_GetMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
14306 PyObject *resultobj;
14307 wxFileType *arg1 = (wxFileType *) 0 ;
14308 PyObject *result;
14309 PyObject * obj0 = 0 ;
14310 char *kwnames[] = {
14311 (char *) "self", NULL
14312 };
14313
14314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetMimeTypes",kwnames,&obj0)) goto fail;
14315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14316 if (SWIG_arg_fail(1)) SWIG_fail;
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (PyObject *)wxFileType_GetMimeTypes(arg1);
14320
14321 wxPyEndAllowThreads(__tstate);
14322 if (PyErr_Occurred()) SWIG_fail;
14323 }
14324 resultobj = result;
14325 return resultobj;
14326 fail:
14327 return NULL;
14328 }
14329
14330
14331 static PyObject *_wrap_FileType_GetExtensions(PyObject *, PyObject *args, PyObject *kwargs) {
14332 PyObject *resultobj;
14333 wxFileType *arg1 = (wxFileType *) 0 ;
14334 PyObject *result;
14335 PyObject * obj0 = 0 ;
14336 char *kwnames[] = {
14337 (char *) "self", NULL
14338 };
14339
14340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetExtensions",kwnames,&obj0)) goto fail;
14341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14342 if (SWIG_arg_fail(1)) SWIG_fail;
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (PyObject *)wxFileType_GetExtensions(arg1);
14346
14347 wxPyEndAllowThreads(__tstate);
14348 if (PyErr_Occurred()) SWIG_fail;
14349 }
14350 resultobj = result;
14351 return resultobj;
14352 fail:
14353 return NULL;
14354 }
14355
14356
14357 static PyObject *_wrap_FileType_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14358 PyObject *resultobj;
14359 wxFileType *arg1 = (wxFileType *) 0 ;
14360 wxIcon *result;
14361 PyObject * obj0 = 0 ;
14362 char *kwnames[] = {
14363 (char *) "self", NULL
14364 };
14365
14366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIcon",kwnames,&obj0)) goto fail;
14367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14368 if (SWIG_arg_fail(1)) SWIG_fail;
14369 {
14370 PyThreadState* __tstate = wxPyBeginAllowThreads();
14371 result = (wxIcon *)wxFileType_GetIcon(arg1);
14372
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIcon, 1);
14377 return resultobj;
14378 fail:
14379 return NULL;
14380 }
14381
14382
14383 static PyObject *_wrap_FileType_GetIconInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14384 PyObject *resultobj;
14385 wxFileType *arg1 = (wxFileType *) 0 ;
14386 PyObject *result;
14387 PyObject * obj0 = 0 ;
14388 char *kwnames[] = {
14389 (char *) "self", NULL
14390 };
14391
14392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetIconInfo",kwnames,&obj0)) goto fail;
14393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14394 if (SWIG_arg_fail(1)) SWIG_fail;
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (PyObject *)wxFileType_GetIconInfo(arg1);
14398
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = result;
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 static PyObject *_wrap_FileType_GetDescription(PyObject *, PyObject *args, PyObject *kwargs) {
14410 PyObject *resultobj;
14411 wxFileType *arg1 = (wxFileType *) 0 ;
14412 PyObject *result;
14413 PyObject * obj0 = 0 ;
14414 char *kwnames[] = {
14415 (char *) "self", NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_GetDescription",kwnames,&obj0)) goto fail;
14419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14420 if (SWIG_arg_fail(1)) SWIG_fail;
14421 {
14422 PyThreadState* __tstate = wxPyBeginAllowThreads();
14423 result = (PyObject *)wxFileType_GetDescription(arg1);
14424
14425 wxPyEndAllowThreads(__tstate);
14426 if (PyErr_Occurred()) SWIG_fail;
14427 }
14428 resultobj = result;
14429 return resultobj;
14430 fail:
14431 return NULL;
14432 }
14433
14434
14435 static PyObject *_wrap_FileType_GetOpenCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14436 PyObject *resultobj;
14437 wxFileType *arg1 = (wxFileType *) 0 ;
14438 wxString *arg2 = 0 ;
14439 wxString const &arg3_defvalue = wxPyEmptyString ;
14440 wxString *arg3 = (wxString *) &arg3_defvalue ;
14441 PyObject *result;
14442 bool temp2 = false ;
14443 bool temp3 = false ;
14444 PyObject * obj0 = 0 ;
14445 PyObject * obj1 = 0 ;
14446 PyObject * obj2 = 0 ;
14447 char *kwnames[] = {
14448 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14449 };
14450
14451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetOpenCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14453 if (SWIG_arg_fail(1)) SWIG_fail;
14454 {
14455 arg2 = wxString_in_helper(obj1);
14456 if (arg2 == NULL) SWIG_fail;
14457 temp2 = true;
14458 }
14459 if (obj2) {
14460 {
14461 arg3 = wxString_in_helper(obj2);
14462 if (arg3 == NULL) SWIG_fail;
14463 temp3 = true;
14464 }
14465 }
14466 {
14467 PyThreadState* __tstate = wxPyBeginAllowThreads();
14468 result = (PyObject *)wxFileType_GetOpenCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14469
14470 wxPyEndAllowThreads(__tstate);
14471 if (PyErr_Occurred()) SWIG_fail;
14472 }
14473 resultobj = result;
14474 {
14475 if (temp2)
14476 delete arg2;
14477 }
14478 {
14479 if (temp3)
14480 delete arg3;
14481 }
14482 return resultobj;
14483 fail:
14484 {
14485 if (temp2)
14486 delete arg2;
14487 }
14488 {
14489 if (temp3)
14490 delete arg3;
14491 }
14492 return NULL;
14493 }
14494
14495
14496 static PyObject *_wrap_FileType_GetPrintCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14497 PyObject *resultobj;
14498 wxFileType *arg1 = (wxFileType *) 0 ;
14499 wxString *arg2 = 0 ;
14500 wxString const &arg3_defvalue = wxPyEmptyString ;
14501 wxString *arg3 = (wxString *) &arg3_defvalue ;
14502 PyObject *result;
14503 bool temp2 = false ;
14504 bool temp3 = false ;
14505 PyObject * obj0 = 0 ;
14506 PyObject * obj1 = 0 ;
14507 PyObject * obj2 = 0 ;
14508 char *kwnames[] = {
14509 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14510 };
14511
14512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetPrintCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14514 if (SWIG_arg_fail(1)) SWIG_fail;
14515 {
14516 arg2 = wxString_in_helper(obj1);
14517 if (arg2 == NULL) SWIG_fail;
14518 temp2 = true;
14519 }
14520 if (obj2) {
14521 {
14522 arg3 = wxString_in_helper(obj2);
14523 if (arg3 == NULL) SWIG_fail;
14524 temp3 = true;
14525 }
14526 }
14527 {
14528 PyThreadState* __tstate = wxPyBeginAllowThreads();
14529 result = (PyObject *)wxFileType_GetPrintCommand(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14530
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 resultobj = result;
14535 {
14536 if (temp2)
14537 delete arg2;
14538 }
14539 {
14540 if (temp3)
14541 delete arg3;
14542 }
14543 return resultobj;
14544 fail:
14545 {
14546 if (temp2)
14547 delete arg2;
14548 }
14549 {
14550 if (temp3)
14551 delete arg3;
14552 }
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_FileType_GetAllCommands(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxFileType *arg1 = (wxFileType *) 0 ;
14560 wxString *arg2 = 0 ;
14561 wxString const &arg3_defvalue = wxPyEmptyString ;
14562 wxString *arg3 = (wxString *) &arg3_defvalue ;
14563 PyObject *result;
14564 bool temp2 = false ;
14565 bool temp3 = false ;
14566 PyObject * obj0 = 0 ;
14567 PyObject * obj1 = 0 ;
14568 PyObject * obj2 = 0 ;
14569 char *kwnames[] = {
14570 (char *) "self",(char *) "filename",(char *) "mimetype", NULL
14571 };
14572
14573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_GetAllCommands",kwnames,&obj0,&obj1,&obj2)) goto fail;
14574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14575 if (SWIG_arg_fail(1)) SWIG_fail;
14576 {
14577 arg2 = wxString_in_helper(obj1);
14578 if (arg2 == NULL) SWIG_fail;
14579 temp2 = true;
14580 }
14581 if (obj2) {
14582 {
14583 arg3 = wxString_in_helper(obj2);
14584 if (arg3 == NULL) SWIG_fail;
14585 temp3 = true;
14586 }
14587 }
14588 {
14589 PyThreadState* __tstate = wxPyBeginAllowThreads();
14590 result = (PyObject *)wxFileType_GetAllCommands(arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14591
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = result;
14596 {
14597 if (temp2)
14598 delete arg2;
14599 }
14600 {
14601 if (temp3)
14602 delete arg3;
14603 }
14604 return resultobj;
14605 fail:
14606 {
14607 if (temp2)
14608 delete arg2;
14609 }
14610 {
14611 if (temp3)
14612 delete arg3;
14613 }
14614 return NULL;
14615 }
14616
14617
14618 static PyObject *_wrap_FileType_SetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14619 PyObject *resultobj;
14620 wxFileType *arg1 = (wxFileType *) 0 ;
14621 wxString *arg2 = 0 ;
14622 wxString *arg3 = 0 ;
14623 bool arg4 = (bool) true ;
14624 bool result;
14625 bool temp2 = false ;
14626 bool temp3 = false ;
14627 PyObject * obj0 = 0 ;
14628 PyObject * obj1 = 0 ;
14629 PyObject * obj2 = 0 ;
14630 PyObject * obj3 = 0 ;
14631 char *kwnames[] = {
14632 (char *) "self",(char *) "cmd",(char *) "verb",(char *) "overwriteprompt", NULL
14633 };
14634
14635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:FileType_SetCommand",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14637 if (SWIG_arg_fail(1)) SWIG_fail;
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 {
14644 arg3 = wxString_in_helper(obj2);
14645 if (arg3 == NULL) SWIG_fail;
14646 temp3 = true;
14647 }
14648 if (obj3) {
14649 {
14650 arg4 = (bool)(SWIG_As_bool(obj3));
14651 if (SWIG_arg_fail(4)) SWIG_fail;
14652 }
14653 }
14654 {
14655 PyThreadState* __tstate = wxPyBeginAllowThreads();
14656 result = (bool)(arg1)->SetCommand((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14657
14658 wxPyEndAllowThreads(__tstate);
14659 if (PyErr_Occurred()) SWIG_fail;
14660 }
14661 {
14662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14663 }
14664 {
14665 if (temp2)
14666 delete arg2;
14667 }
14668 {
14669 if (temp3)
14670 delete arg3;
14671 }
14672 return resultobj;
14673 fail:
14674 {
14675 if (temp2)
14676 delete arg2;
14677 }
14678 {
14679 if (temp3)
14680 delete arg3;
14681 }
14682 return NULL;
14683 }
14684
14685
14686 static PyObject *_wrap_FileType_SetDefaultIcon(PyObject *, PyObject *args, PyObject *kwargs) {
14687 PyObject *resultobj;
14688 wxFileType *arg1 = (wxFileType *) 0 ;
14689 wxString const &arg2_defvalue = wxPyEmptyString ;
14690 wxString *arg2 = (wxString *) &arg2_defvalue ;
14691 int arg3 = (int) 0 ;
14692 bool result;
14693 bool temp2 = false ;
14694 PyObject * obj0 = 0 ;
14695 PyObject * obj1 = 0 ;
14696 PyObject * obj2 = 0 ;
14697 char *kwnames[] = {
14698 (char *) "self",(char *) "cmd",(char *) "index", NULL
14699 };
14700
14701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:FileType_SetDefaultIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
14702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14703 if (SWIG_arg_fail(1)) SWIG_fail;
14704 if (obj1) {
14705 {
14706 arg2 = wxString_in_helper(obj1);
14707 if (arg2 == NULL) SWIG_fail;
14708 temp2 = true;
14709 }
14710 }
14711 if (obj2) {
14712 {
14713 arg3 = (int)(SWIG_As_int(obj2));
14714 if (SWIG_arg_fail(3)) SWIG_fail;
14715 }
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)(arg1)->SetDefaultIcon((wxString const &)*arg2,arg3);
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 return resultobj;
14732 fail:
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 return NULL;
14738 }
14739
14740
14741 static PyObject *_wrap_FileType_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj;
14743 wxFileType *arg1 = (wxFileType *) 0 ;
14744 bool result;
14745 PyObject * obj0 = 0 ;
14746 char *kwnames[] = {
14747 (char *) "self", NULL
14748 };
14749
14750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileType_Unassociate",kwnames,&obj0)) goto fail;
14751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(1)) SWIG_fail;
14753 {
14754 PyThreadState* __tstate = wxPyBeginAllowThreads();
14755 result = (bool)(arg1)->Unassociate();
14756
14757 wxPyEndAllowThreads(__tstate);
14758 if (PyErr_Occurred()) SWIG_fail;
14759 }
14760 {
14761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14762 }
14763 return resultobj;
14764 fail:
14765 return NULL;
14766 }
14767
14768
14769 static PyObject *_wrap_FileType_ExpandCommand(PyObject *, PyObject *args, PyObject *kwargs) {
14770 PyObject *resultobj;
14771 wxString *arg1 = 0 ;
14772 wxString *arg2 = 0 ;
14773 wxString const &arg3_defvalue = wxPyEmptyString ;
14774 wxString *arg3 = (wxString *) &arg3_defvalue ;
14775 wxString result;
14776 bool temp1 = false ;
14777 bool temp2 = false ;
14778 bool temp3 = false ;
14779 PyObject * obj0 = 0 ;
14780 PyObject * obj1 = 0 ;
14781 PyObject * obj2 = 0 ;
14782 char *kwnames[] = {
14783 (char *) "command",(char *) "filename",(char *) "mimetype", NULL
14784 };
14785
14786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileType_ExpandCommand",kwnames,&obj0,&obj1,&obj2)) goto fail;
14787 {
14788 arg1 = wxString_in_helper(obj0);
14789 if (arg1 == NULL) SWIG_fail;
14790 temp1 = true;
14791 }
14792 {
14793 arg2 = wxString_in_helper(obj1);
14794 if (arg2 == NULL) SWIG_fail;
14795 temp2 = true;
14796 }
14797 if (obj2) {
14798 {
14799 arg3 = wxString_in_helper(obj2);
14800 if (arg3 == NULL) SWIG_fail;
14801 temp3 = true;
14802 }
14803 }
14804 {
14805 PyThreadState* __tstate = wxPyBeginAllowThreads();
14806 result = FileType_ExpandCommand((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3);
14807
14808 wxPyEndAllowThreads(__tstate);
14809 if (PyErr_Occurred()) SWIG_fail;
14810 }
14811 {
14812 #if wxUSE_UNICODE
14813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14814 #else
14815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14816 #endif
14817 }
14818 {
14819 if (temp1)
14820 delete arg1;
14821 }
14822 {
14823 if (temp2)
14824 delete arg2;
14825 }
14826 {
14827 if (temp3)
14828 delete arg3;
14829 }
14830 return resultobj;
14831 fail:
14832 {
14833 if (temp1)
14834 delete arg1;
14835 }
14836 {
14837 if (temp2)
14838 delete arg2;
14839 }
14840 {
14841 if (temp3)
14842 delete arg3;
14843 }
14844 return NULL;
14845 }
14846
14847
14848 static PyObject * FileType_swigregister(PyObject *, PyObject *args) {
14849 PyObject *obj;
14850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14851 SWIG_TypeClientData(SWIGTYPE_p_wxFileType, obj);
14852 Py_INCREF(obj);
14853 return Py_BuildValue((char *)"");
14854 }
14855 static int _wrap_TheMimeTypesManager_set(PyObject *) {
14856 PyErr_SetString(PyExc_TypeError,"Variable TheMimeTypesManager is read-only.");
14857 return 1;
14858 }
14859
14860
14861 static PyObject *_wrap_TheMimeTypesManager_get(void) {
14862 PyObject *pyobj;
14863
14864 pyobj = SWIG_NewPointerObj((void *)(wxTheMimeTypesManager), SWIGTYPE_p_wxMimeTypesManager, 0);
14865 return pyobj;
14866 }
14867
14868
14869 static PyObject *_wrap_MimeTypesManager_IsOfType(PyObject *, PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj;
14871 wxString *arg1 = 0 ;
14872 wxString *arg2 = 0 ;
14873 bool result;
14874 bool temp1 = false ;
14875 bool temp2 = false ;
14876 PyObject * obj0 = 0 ;
14877 PyObject * obj1 = 0 ;
14878 char *kwnames[] = {
14879 (char *) "mimeType",(char *) "wildcard", NULL
14880 };
14881
14882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_IsOfType",kwnames,&obj0,&obj1)) goto fail;
14883 {
14884 arg1 = wxString_in_helper(obj0);
14885 if (arg1 == NULL) SWIG_fail;
14886 temp1 = true;
14887 }
14888 {
14889 arg2 = wxString_in_helper(obj1);
14890 if (arg2 == NULL) SWIG_fail;
14891 temp2 = true;
14892 }
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 result = (bool)wxMimeTypesManager::IsOfType((wxString const &)*arg1,(wxString const &)*arg2);
14896
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 {
14901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14902 }
14903 {
14904 if (temp1)
14905 delete arg1;
14906 }
14907 {
14908 if (temp2)
14909 delete arg2;
14910 }
14911 return resultobj;
14912 fail:
14913 {
14914 if (temp1)
14915 delete arg1;
14916 }
14917 {
14918 if (temp2)
14919 delete arg2;
14920 }
14921 return NULL;
14922 }
14923
14924
14925 static PyObject *_wrap_new_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
14926 PyObject *resultobj;
14927 wxMimeTypesManager *result;
14928 char *kwnames[] = {
14929 NULL
14930 };
14931
14932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MimeTypesManager",kwnames)) goto fail;
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (wxMimeTypesManager *)new wxMimeTypesManager();
14936
14937 wxPyEndAllowThreads(__tstate);
14938 if (PyErr_Occurred()) SWIG_fail;
14939 }
14940 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMimeTypesManager, 1);
14941 return resultobj;
14942 fail:
14943 return NULL;
14944 }
14945
14946
14947 static PyObject *_wrap_MimeTypesManager_Initialize(PyObject *, PyObject *args, PyObject *kwargs) {
14948 PyObject *resultobj;
14949 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
14950 int arg2 = (int) wxMAILCAP_ALL ;
14951 wxString const &arg3_defvalue = wxPyEmptyString ;
14952 wxString *arg3 = (wxString *) &arg3_defvalue ;
14953 bool temp3 = false ;
14954 PyObject * obj0 = 0 ;
14955 PyObject * obj1 = 0 ;
14956 PyObject * obj2 = 0 ;
14957 char *kwnames[] = {
14958 (char *) "self",(char *) "mailcapStyle",(char *) "extraDir", NULL
14959 };
14960
14961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:MimeTypesManager_Initialize",kwnames,&obj0,&obj1,&obj2)) goto fail;
14962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
14963 if (SWIG_arg_fail(1)) SWIG_fail;
14964 if (obj1) {
14965 {
14966 arg2 = (int)(SWIG_As_int(obj1));
14967 if (SWIG_arg_fail(2)) SWIG_fail;
14968 }
14969 }
14970 if (obj2) {
14971 {
14972 arg3 = wxString_in_helper(obj2);
14973 if (arg3 == NULL) SWIG_fail;
14974 temp3 = true;
14975 }
14976 }
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 (arg1)->Initialize(arg2,(wxString const &)*arg3);
14980
14981 wxPyEndAllowThreads(__tstate);
14982 if (PyErr_Occurred()) SWIG_fail;
14983 }
14984 Py_INCREF(Py_None); resultobj = Py_None;
14985 {
14986 if (temp3)
14987 delete arg3;
14988 }
14989 return resultobj;
14990 fail:
14991 {
14992 if (temp3)
14993 delete arg3;
14994 }
14995 return NULL;
14996 }
14997
14998
14999 static PyObject *_wrap_MimeTypesManager_ClearData(PyObject *, PyObject *args, PyObject *kwargs) {
15000 PyObject *resultobj;
15001 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15002 PyObject * obj0 = 0 ;
15003 char *kwnames[] = {
15004 (char *) "self", NULL
15005 };
15006
15007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_ClearData",kwnames,&obj0)) goto fail;
15008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15009 if (SWIG_arg_fail(1)) SWIG_fail;
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 (arg1)->ClearData();
15013
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 Py_INCREF(Py_None); resultobj = Py_None;
15018 return resultobj;
15019 fail:
15020 return NULL;
15021 }
15022
15023
15024 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromExtension(PyObject *, PyObject *args, PyObject *kwargs) {
15025 PyObject *resultobj;
15026 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15027 wxString *arg2 = 0 ;
15028 wxFileType *result;
15029 bool temp2 = false ;
15030 PyObject * obj0 = 0 ;
15031 PyObject * obj1 = 0 ;
15032 char *kwnames[] = {
15033 (char *) "self",(char *) "ext", NULL
15034 };
15035
15036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromExtension",kwnames,&obj0,&obj1)) goto fail;
15037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15038 if (SWIG_arg_fail(1)) SWIG_fail;
15039 {
15040 arg2 = wxString_in_helper(obj1);
15041 if (arg2 == NULL) SWIG_fail;
15042 temp2 = true;
15043 }
15044 {
15045 PyThreadState* __tstate = wxPyBeginAllowThreads();
15046 result = (wxFileType *)(arg1)->GetFileTypeFromExtension((wxString const &)*arg2);
15047
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15052 {
15053 if (temp2)
15054 delete arg2;
15055 }
15056 return resultobj;
15057 fail:
15058 {
15059 if (temp2)
15060 delete arg2;
15061 }
15062 return NULL;
15063 }
15064
15065
15066 static PyObject *_wrap_MimeTypesManager_GetFileTypeFromMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
15067 PyObject *resultobj;
15068 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15069 wxString *arg2 = 0 ;
15070 wxFileType *result;
15071 bool temp2 = false ;
15072 PyObject * obj0 = 0 ;
15073 PyObject * obj1 = 0 ;
15074 char *kwnames[] = {
15075 (char *) "self",(char *) "mimeType", NULL
15076 };
15077
15078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_GetFileTypeFromMimeType",kwnames,&obj0,&obj1)) goto fail;
15079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15080 if (SWIG_arg_fail(1)) SWIG_fail;
15081 {
15082 arg2 = wxString_in_helper(obj1);
15083 if (arg2 == NULL) SWIG_fail;
15084 temp2 = true;
15085 }
15086 {
15087 PyThreadState* __tstate = wxPyBeginAllowThreads();
15088 result = (wxFileType *)(arg1)->GetFileTypeFromMimeType((wxString const &)*arg2);
15089
15090 wxPyEndAllowThreads(__tstate);
15091 if (PyErr_Occurred()) SWIG_fail;
15092 }
15093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15094 {
15095 if (temp2)
15096 delete arg2;
15097 }
15098 return resultobj;
15099 fail:
15100 {
15101 if (temp2)
15102 delete arg2;
15103 }
15104 return NULL;
15105 }
15106
15107
15108 static PyObject *_wrap_MimeTypesManager_ReadMailcap(PyObject *, PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj;
15110 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15111 wxString *arg2 = 0 ;
15112 bool arg3 = (bool) false ;
15113 bool result;
15114 bool temp2 = false ;
15115 PyObject * obj0 = 0 ;
15116 PyObject * obj1 = 0 ;
15117 PyObject * obj2 = 0 ;
15118 char *kwnames[] = {
15119 (char *) "self",(char *) "filename",(char *) "fallback", NULL
15120 };
15121
15122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MimeTypesManager_ReadMailcap",kwnames,&obj0,&obj1,&obj2)) goto fail;
15123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15124 if (SWIG_arg_fail(1)) SWIG_fail;
15125 {
15126 arg2 = wxString_in_helper(obj1);
15127 if (arg2 == NULL) SWIG_fail;
15128 temp2 = true;
15129 }
15130 if (obj2) {
15131 {
15132 arg3 = (bool)(SWIG_As_bool(obj2));
15133 if (SWIG_arg_fail(3)) SWIG_fail;
15134 }
15135 }
15136 {
15137 PyThreadState* __tstate = wxPyBeginAllowThreads();
15138 result = (bool)(arg1)->ReadMailcap((wxString const &)*arg2,arg3);
15139
15140 wxPyEndAllowThreads(__tstate);
15141 if (PyErr_Occurred()) SWIG_fail;
15142 }
15143 {
15144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15145 }
15146 {
15147 if (temp2)
15148 delete arg2;
15149 }
15150 return resultobj;
15151 fail:
15152 {
15153 if (temp2)
15154 delete arg2;
15155 }
15156 return NULL;
15157 }
15158
15159
15160 static PyObject *_wrap_MimeTypesManager_ReadMimeTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15161 PyObject *resultobj;
15162 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15163 wxString *arg2 = 0 ;
15164 bool result;
15165 bool temp2 = false ;
15166 PyObject * obj0 = 0 ;
15167 PyObject * obj1 = 0 ;
15168 char *kwnames[] = {
15169 (char *) "self",(char *) "filename", NULL
15170 };
15171
15172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_ReadMimeTypes",kwnames,&obj0,&obj1)) goto fail;
15173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15174 if (SWIG_arg_fail(1)) SWIG_fail;
15175 {
15176 arg2 = wxString_in_helper(obj1);
15177 if (arg2 == NULL) SWIG_fail;
15178 temp2 = true;
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->ReadMimeTypes((wxString const &)*arg2);
15183
15184 wxPyEndAllowThreads(__tstate);
15185 if (PyErr_Occurred()) SWIG_fail;
15186 }
15187 {
15188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15189 }
15190 {
15191 if (temp2)
15192 delete arg2;
15193 }
15194 return resultobj;
15195 fail:
15196 {
15197 if (temp2)
15198 delete arg2;
15199 }
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_MimeTypesManager_EnumAllFileTypes(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15207 PyObject *result;
15208 PyObject * obj0 = 0 ;
15209 char *kwnames[] = {
15210 (char *) "self", NULL
15211 };
15212
15213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MimeTypesManager_EnumAllFileTypes",kwnames,&obj0)) goto fail;
15214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15215 if (SWIG_arg_fail(1)) SWIG_fail;
15216 {
15217 PyThreadState* __tstate = wxPyBeginAllowThreads();
15218 result = (PyObject *)wxMimeTypesManager_EnumAllFileTypes(arg1);
15219
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 resultobj = result;
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 static PyObject *_wrap_MimeTypesManager_AddFallback(PyObject *, PyObject *args, PyObject *kwargs) {
15231 PyObject *resultobj;
15232 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15233 wxFileTypeInfo *arg2 = 0 ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "self",(char *) "ft", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_AddFallback",kwnames,&obj0,&obj1)) goto fail;
15241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15242 if (SWIG_arg_fail(1)) SWIG_fail;
15243 {
15244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15245 if (SWIG_arg_fail(2)) SWIG_fail;
15246 if (arg2 == NULL) {
15247 SWIG_null_ref("wxFileTypeInfo");
15248 }
15249 if (SWIG_arg_fail(2)) SWIG_fail;
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 (arg1)->AddFallback((wxFileTypeInfo const &)*arg2);
15254
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 Py_INCREF(Py_None); resultobj = Py_None;
15259 return resultobj;
15260 fail:
15261 return NULL;
15262 }
15263
15264
15265 static PyObject *_wrap_MimeTypesManager_Associate(PyObject *, PyObject *args, PyObject *kwargs) {
15266 PyObject *resultobj;
15267 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15268 wxFileTypeInfo *arg2 = 0 ;
15269 wxFileType *result;
15270 PyObject * obj0 = 0 ;
15271 PyObject * obj1 = 0 ;
15272 char *kwnames[] = {
15273 (char *) "self",(char *) "ftInfo", NULL
15274 };
15275
15276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Associate",kwnames,&obj0,&obj1)) goto fail;
15277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15278 if (SWIG_arg_fail(1)) SWIG_fail;
15279 {
15280 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileTypeInfo, SWIG_POINTER_EXCEPTION | 0);
15281 if (SWIG_arg_fail(2)) SWIG_fail;
15282 if (arg2 == NULL) {
15283 SWIG_null_ref("wxFileTypeInfo");
15284 }
15285 if (SWIG_arg_fail(2)) SWIG_fail;
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (wxFileType *)(arg1)->Associate((wxFileTypeInfo const &)*arg2);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileType, 1);
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_MimeTypesManager_Unassociate(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15304 wxFileType *arg2 = (wxFileType *) 0 ;
15305 bool result;
15306 PyObject * obj0 = 0 ;
15307 PyObject * obj1 = 0 ;
15308 char *kwnames[] = {
15309 (char *) "self",(char *) "ft", NULL
15310 };
15311
15312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MimeTypesManager_Unassociate",kwnames,&obj0,&obj1)) goto fail;
15313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15314 if (SWIG_arg_fail(1)) SWIG_fail;
15315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileType, SWIG_POINTER_EXCEPTION | 0);
15316 if (SWIG_arg_fail(2)) SWIG_fail;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 result = (bool)(arg1)->Unassociate(arg2);
15320
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 {
15325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15326 }
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 static PyObject *_wrap_delete_MimeTypesManager(PyObject *, PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj;
15335 wxMimeTypesManager *arg1 = (wxMimeTypesManager *) 0 ;
15336 PyObject * obj0 = 0 ;
15337 char *kwnames[] = {
15338 (char *) "self", NULL
15339 };
15340
15341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_MimeTypesManager",kwnames,&obj0)) goto fail;
15342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMimeTypesManager, SWIG_POINTER_EXCEPTION | 0);
15343 if (SWIG_arg_fail(1)) SWIG_fail;
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 delete arg1;
15347
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 Py_INCREF(Py_None); resultobj = Py_None;
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 static PyObject * MimeTypesManager_swigregister(PyObject *, PyObject *args) {
15359 PyObject *obj;
15360 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15361 SWIG_TypeClientData(SWIGTYPE_p_wxMimeTypesManager, obj);
15362 Py_INCREF(obj);
15363 return Py_BuildValue((char *)"");
15364 }
15365 static int _wrap_ART_TOOLBAR_set(PyObject *) {
15366 PyErr_SetString(PyExc_TypeError,"Variable ART_TOOLBAR is read-only.");
15367 return 1;
15368 }
15369
15370
15371 static PyObject *_wrap_ART_TOOLBAR_get(void) {
15372 PyObject *pyobj;
15373
15374 {
15375 #if wxUSE_UNICODE
15376 pyobj = PyUnicode_FromWideChar((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15377 #else
15378 pyobj = PyString_FromStringAndSize((&wxPyART_TOOLBAR)->c_str(), (&wxPyART_TOOLBAR)->Len());
15379 #endif
15380 }
15381 return pyobj;
15382 }
15383
15384
15385 static int _wrap_ART_MENU_set(PyObject *) {
15386 PyErr_SetString(PyExc_TypeError,"Variable ART_MENU is read-only.");
15387 return 1;
15388 }
15389
15390
15391 static PyObject *_wrap_ART_MENU_get(void) {
15392 PyObject *pyobj;
15393
15394 {
15395 #if wxUSE_UNICODE
15396 pyobj = PyUnicode_FromWideChar((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15397 #else
15398 pyobj = PyString_FromStringAndSize((&wxPyART_MENU)->c_str(), (&wxPyART_MENU)->Len());
15399 #endif
15400 }
15401 return pyobj;
15402 }
15403
15404
15405 static int _wrap_ART_FRAME_ICON_set(PyObject *) {
15406 PyErr_SetString(PyExc_TypeError,"Variable ART_FRAME_ICON is read-only.");
15407 return 1;
15408 }
15409
15410
15411 static PyObject *_wrap_ART_FRAME_ICON_get(void) {
15412 PyObject *pyobj;
15413
15414 {
15415 #if wxUSE_UNICODE
15416 pyobj = PyUnicode_FromWideChar((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15417 #else
15418 pyobj = PyString_FromStringAndSize((&wxPyART_FRAME_ICON)->c_str(), (&wxPyART_FRAME_ICON)->Len());
15419 #endif
15420 }
15421 return pyobj;
15422 }
15423
15424
15425 static int _wrap_ART_CMN_DIALOG_set(PyObject *) {
15426 PyErr_SetString(PyExc_TypeError,"Variable ART_CMN_DIALOG is read-only.");
15427 return 1;
15428 }
15429
15430
15431 static PyObject *_wrap_ART_CMN_DIALOG_get(void) {
15432 PyObject *pyobj;
15433
15434 {
15435 #if wxUSE_UNICODE
15436 pyobj = PyUnicode_FromWideChar((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15437 #else
15438 pyobj = PyString_FromStringAndSize((&wxPyART_CMN_DIALOG)->c_str(), (&wxPyART_CMN_DIALOG)->Len());
15439 #endif
15440 }
15441 return pyobj;
15442 }
15443
15444
15445 static int _wrap_ART_HELP_BROWSER_set(PyObject *) {
15446 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BROWSER is read-only.");
15447 return 1;
15448 }
15449
15450
15451 static PyObject *_wrap_ART_HELP_BROWSER_get(void) {
15452 PyObject *pyobj;
15453
15454 {
15455 #if wxUSE_UNICODE
15456 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15457 #else
15458 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BROWSER)->c_str(), (&wxPyART_HELP_BROWSER)->Len());
15459 #endif
15460 }
15461 return pyobj;
15462 }
15463
15464
15465 static int _wrap_ART_MESSAGE_BOX_set(PyObject *) {
15466 PyErr_SetString(PyExc_TypeError,"Variable ART_MESSAGE_BOX is read-only.");
15467 return 1;
15468 }
15469
15470
15471 static PyObject *_wrap_ART_MESSAGE_BOX_get(void) {
15472 PyObject *pyobj;
15473
15474 {
15475 #if wxUSE_UNICODE
15476 pyobj = PyUnicode_FromWideChar((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15477 #else
15478 pyobj = PyString_FromStringAndSize((&wxPyART_MESSAGE_BOX)->c_str(), (&wxPyART_MESSAGE_BOX)->Len());
15479 #endif
15480 }
15481 return pyobj;
15482 }
15483
15484
15485 static int _wrap_ART_BUTTON_set(PyObject *) {
15486 PyErr_SetString(PyExc_TypeError,"Variable ART_BUTTON is read-only.");
15487 return 1;
15488 }
15489
15490
15491 static PyObject *_wrap_ART_BUTTON_get(void) {
15492 PyObject *pyobj;
15493
15494 {
15495 #if wxUSE_UNICODE
15496 pyobj = PyUnicode_FromWideChar((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15497 #else
15498 pyobj = PyString_FromStringAndSize((&wxPyART_BUTTON)->c_str(), (&wxPyART_BUTTON)->Len());
15499 #endif
15500 }
15501 return pyobj;
15502 }
15503
15504
15505 static int _wrap_ART_OTHER_set(PyObject *) {
15506 PyErr_SetString(PyExc_TypeError,"Variable ART_OTHER is read-only.");
15507 return 1;
15508 }
15509
15510
15511 static PyObject *_wrap_ART_OTHER_get(void) {
15512 PyObject *pyobj;
15513
15514 {
15515 #if wxUSE_UNICODE
15516 pyobj = PyUnicode_FromWideChar((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15517 #else
15518 pyobj = PyString_FromStringAndSize((&wxPyART_OTHER)->c_str(), (&wxPyART_OTHER)->Len());
15519 #endif
15520 }
15521 return pyobj;
15522 }
15523
15524
15525 static int _wrap_ART_ADD_BOOKMARK_set(PyObject *) {
15526 PyErr_SetString(PyExc_TypeError,"Variable ART_ADD_BOOKMARK is read-only.");
15527 return 1;
15528 }
15529
15530
15531 static PyObject *_wrap_ART_ADD_BOOKMARK_get(void) {
15532 PyObject *pyobj;
15533
15534 {
15535 #if wxUSE_UNICODE
15536 pyobj = PyUnicode_FromWideChar((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15537 #else
15538 pyobj = PyString_FromStringAndSize((&wxPyART_ADD_BOOKMARK)->c_str(), (&wxPyART_ADD_BOOKMARK)->Len());
15539 #endif
15540 }
15541 return pyobj;
15542 }
15543
15544
15545 static int _wrap_ART_DEL_BOOKMARK_set(PyObject *) {
15546 PyErr_SetString(PyExc_TypeError,"Variable ART_DEL_BOOKMARK is read-only.");
15547 return 1;
15548 }
15549
15550
15551 static PyObject *_wrap_ART_DEL_BOOKMARK_get(void) {
15552 PyObject *pyobj;
15553
15554 {
15555 #if wxUSE_UNICODE
15556 pyobj = PyUnicode_FromWideChar((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15557 #else
15558 pyobj = PyString_FromStringAndSize((&wxPyART_DEL_BOOKMARK)->c_str(), (&wxPyART_DEL_BOOKMARK)->Len());
15559 #endif
15560 }
15561 return pyobj;
15562 }
15563
15564
15565 static int _wrap_ART_HELP_SIDE_PANEL_set(PyObject *) {
15566 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SIDE_PANEL is read-only.");
15567 return 1;
15568 }
15569
15570
15571 static PyObject *_wrap_ART_HELP_SIDE_PANEL_get(void) {
15572 PyObject *pyobj;
15573
15574 {
15575 #if wxUSE_UNICODE
15576 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15577 #else
15578 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SIDE_PANEL)->c_str(), (&wxPyART_HELP_SIDE_PANEL)->Len());
15579 #endif
15580 }
15581 return pyobj;
15582 }
15583
15584
15585 static int _wrap_ART_HELP_SETTINGS_set(PyObject *) {
15586 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_SETTINGS is read-only.");
15587 return 1;
15588 }
15589
15590
15591 static PyObject *_wrap_ART_HELP_SETTINGS_get(void) {
15592 PyObject *pyobj;
15593
15594 {
15595 #if wxUSE_UNICODE
15596 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15597 #else
15598 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_SETTINGS)->c_str(), (&wxPyART_HELP_SETTINGS)->Len());
15599 #endif
15600 }
15601 return pyobj;
15602 }
15603
15604
15605 static int _wrap_ART_HELP_BOOK_set(PyObject *) {
15606 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_BOOK is read-only.");
15607 return 1;
15608 }
15609
15610
15611 static PyObject *_wrap_ART_HELP_BOOK_get(void) {
15612 PyObject *pyobj;
15613
15614 {
15615 #if wxUSE_UNICODE
15616 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15617 #else
15618 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_BOOK)->c_str(), (&wxPyART_HELP_BOOK)->Len());
15619 #endif
15620 }
15621 return pyobj;
15622 }
15623
15624
15625 static int _wrap_ART_HELP_FOLDER_set(PyObject *) {
15626 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_FOLDER is read-only.");
15627 return 1;
15628 }
15629
15630
15631 static PyObject *_wrap_ART_HELP_FOLDER_get(void) {
15632 PyObject *pyobj;
15633
15634 {
15635 #if wxUSE_UNICODE
15636 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15637 #else
15638 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_FOLDER)->c_str(), (&wxPyART_HELP_FOLDER)->Len());
15639 #endif
15640 }
15641 return pyobj;
15642 }
15643
15644
15645 static int _wrap_ART_HELP_PAGE_set(PyObject *) {
15646 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP_PAGE is read-only.");
15647 return 1;
15648 }
15649
15650
15651 static PyObject *_wrap_ART_HELP_PAGE_get(void) {
15652 PyObject *pyobj;
15653
15654 {
15655 #if wxUSE_UNICODE
15656 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15657 #else
15658 pyobj = PyString_FromStringAndSize((&wxPyART_HELP_PAGE)->c_str(), (&wxPyART_HELP_PAGE)->Len());
15659 #endif
15660 }
15661 return pyobj;
15662 }
15663
15664
15665 static int _wrap_ART_GO_BACK_set(PyObject *) {
15666 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_BACK is read-only.");
15667 return 1;
15668 }
15669
15670
15671 static PyObject *_wrap_ART_GO_BACK_get(void) {
15672 PyObject *pyobj;
15673
15674 {
15675 #if wxUSE_UNICODE
15676 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15677 #else
15678 pyobj = PyString_FromStringAndSize((&wxPyART_GO_BACK)->c_str(), (&wxPyART_GO_BACK)->Len());
15679 #endif
15680 }
15681 return pyobj;
15682 }
15683
15684
15685 static int _wrap_ART_GO_FORWARD_set(PyObject *) {
15686 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_FORWARD is read-only.");
15687 return 1;
15688 }
15689
15690
15691 static PyObject *_wrap_ART_GO_FORWARD_get(void) {
15692 PyObject *pyobj;
15693
15694 {
15695 #if wxUSE_UNICODE
15696 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15697 #else
15698 pyobj = PyString_FromStringAndSize((&wxPyART_GO_FORWARD)->c_str(), (&wxPyART_GO_FORWARD)->Len());
15699 #endif
15700 }
15701 return pyobj;
15702 }
15703
15704
15705 static int _wrap_ART_GO_UP_set(PyObject *) {
15706 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_UP is read-only.");
15707 return 1;
15708 }
15709
15710
15711 static PyObject *_wrap_ART_GO_UP_get(void) {
15712 PyObject *pyobj;
15713
15714 {
15715 #if wxUSE_UNICODE
15716 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15717 #else
15718 pyobj = PyString_FromStringAndSize((&wxPyART_GO_UP)->c_str(), (&wxPyART_GO_UP)->Len());
15719 #endif
15720 }
15721 return pyobj;
15722 }
15723
15724
15725 static int _wrap_ART_GO_DOWN_set(PyObject *) {
15726 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DOWN is read-only.");
15727 return 1;
15728 }
15729
15730
15731 static PyObject *_wrap_ART_GO_DOWN_get(void) {
15732 PyObject *pyobj;
15733
15734 {
15735 #if wxUSE_UNICODE
15736 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15737 #else
15738 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DOWN)->c_str(), (&wxPyART_GO_DOWN)->Len());
15739 #endif
15740 }
15741 return pyobj;
15742 }
15743
15744
15745 static int _wrap_ART_GO_TO_PARENT_set(PyObject *) {
15746 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_TO_PARENT is read-only.");
15747 return 1;
15748 }
15749
15750
15751 static PyObject *_wrap_ART_GO_TO_PARENT_get(void) {
15752 PyObject *pyobj;
15753
15754 {
15755 #if wxUSE_UNICODE
15756 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15757 #else
15758 pyobj = PyString_FromStringAndSize((&wxPyART_GO_TO_PARENT)->c_str(), (&wxPyART_GO_TO_PARENT)->Len());
15759 #endif
15760 }
15761 return pyobj;
15762 }
15763
15764
15765 static int _wrap_ART_GO_HOME_set(PyObject *) {
15766 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_HOME is read-only.");
15767 return 1;
15768 }
15769
15770
15771 static PyObject *_wrap_ART_GO_HOME_get(void) {
15772 PyObject *pyobj;
15773
15774 {
15775 #if wxUSE_UNICODE
15776 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15777 #else
15778 pyobj = PyString_FromStringAndSize((&wxPyART_GO_HOME)->c_str(), (&wxPyART_GO_HOME)->Len());
15779 #endif
15780 }
15781 return pyobj;
15782 }
15783
15784
15785 static int _wrap_ART_FILE_OPEN_set(PyObject *) {
15786 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_OPEN is read-only.");
15787 return 1;
15788 }
15789
15790
15791 static PyObject *_wrap_ART_FILE_OPEN_get(void) {
15792 PyObject *pyobj;
15793
15794 {
15795 #if wxUSE_UNICODE
15796 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15797 #else
15798 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_OPEN)->c_str(), (&wxPyART_FILE_OPEN)->Len());
15799 #endif
15800 }
15801 return pyobj;
15802 }
15803
15804
15805 static int _wrap_ART_FILE_SAVE_set(PyObject *) {
15806 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE is read-only.");
15807 return 1;
15808 }
15809
15810
15811 static PyObject *_wrap_ART_FILE_SAVE_get(void) {
15812 PyObject *pyobj;
15813
15814 {
15815 #if wxUSE_UNICODE
15816 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15817 #else
15818 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE)->c_str(), (&wxPyART_FILE_SAVE)->Len());
15819 #endif
15820 }
15821 return pyobj;
15822 }
15823
15824
15825 static int _wrap_ART_FILE_SAVE_AS_set(PyObject *) {
15826 PyErr_SetString(PyExc_TypeError,"Variable ART_FILE_SAVE_AS is read-only.");
15827 return 1;
15828 }
15829
15830
15831 static PyObject *_wrap_ART_FILE_SAVE_AS_get(void) {
15832 PyObject *pyobj;
15833
15834 {
15835 #if wxUSE_UNICODE
15836 pyobj = PyUnicode_FromWideChar((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15837 #else
15838 pyobj = PyString_FromStringAndSize((&wxPyART_FILE_SAVE_AS)->c_str(), (&wxPyART_FILE_SAVE_AS)->Len());
15839 #endif
15840 }
15841 return pyobj;
15842 }
15843
15844
15845 static int _wrap_ART_PRINT_set(PyObject *) {
15846 PyErr_SetString(PyExc_TypeError,"Variable ART_PRINT is read-only.");
15847 return 1;
15848 }
15849
15850
15851 static PyObject *_wrap_ART_PRINT_get(void) {
15852 PyObject *pyobj;
15853
15854 {
15855 #if wxUSE_UNICODE
15856 pyobj = PyUnicode_FromWideChar((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15857 #else
15858 pyobj = PyString_FromStringAndSize((&wxPyART_PRINT)->c_str(), (&wxPyART_PRINT)->Len());
15859 #endif
15860 }
15861 return pyobj;
15862 }
15863
15864
15865 static int _wrap_ART_HELP_set(PyObject *) {
15866 PyErr_SetString(PyExc_TypeError,"Variable ART_HELP is read-only.");
15867 return 1;
15868 }
15869
15870
15871 static PyObject *_wrap_ART_HELP_get(void) {
15872 PyObject *pyobj;
15873
15874 {
15875 #if wxUSE_UNICODE
15876 pyobj = PyUnicode_FromWideChar((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15877 #else
15878 pyobj = PyString_FromStringAndSize((&wxPyART_HELP)->c_str(), (&wxPyART_HELP)->Len());
15879 #endif
15880 }
15881 return pyobj;
15882 }
15883
15884
15885 static int _wrap_ART_TIP_set(PyObject *) {
15886 PyErr_SetString(PyExc_TypeError,"Variable ART_TIP is read-only.");
15887 return 1;
15888 }
15889
15890
15891 static PyObject *_wrap_ART_TIP_get(void) {
15892 PyObject *pyobj;
15893
15894 {
15895 #if wxUSE_UNICODE
15896 pyobj = PyUnicode_FromWideChar((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15897 #else
15898 pyobj = PyString_FromStringAndSize((&wxPyART_TIP)->c_str(), (&wxPyART_TIP)->Len());
15899 #endif
15900 }
15901 return pyobj;
15902 }
15903
15904
15905 static int _wrap_ART_REPORT_VIEW_set(PyObject *) {
15906 PyErr_SetString(PyExc_TypeError,"Variable ART_REPORT_VIEW is read-only.");
15907 return 1;
15908 }
15909
15910
15911 static PyObject *_wrap_ART_REPORT_VIEW_get(void) {
15912 PyObject *pyobj;
15913
15914 {
15915 #if wxUSE_UNICODE
15916 pyobj = PyUnicode_FromWideChar((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15917 #else
15918 pyobj = PyString_FromStringAndSize((&wxPyART_REPORT_VIEW)->c_str(), (&wxPyART_REPORT_VIEW)->Len());
15919 #endif
15920 }
15921 return pyobj;
15922 }
15923
15924
15925 static int _wrap_ART_LIST_VIEW_set(PyObject *) {
15926 PyErr_SetString(PyExc_TypeError,"Variable ART_LIST_VIEW is read-only.");
15927 return 1;
15928 }
15929
15930
15931 static PyObject *_wrap_ART_LIST_VIEW_get(void) {
15932 PyObject *pyobj;
15933
15934 {
15935 #if wxUSE_UNICODE
15936 pyobj = PyUnicode_FromWideChar((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15937 #else
15938 pyobj = PyString_FromStringAndSize((&wxPyART_LIST_VIEW)->c_str(), (&wxPyART_LIST_VIEW)->Len());
15939 #endif
15940 }
15941 return pyobj;
15942 }
15943
15944
15945 static int _wrap_ART_NEW_DIR_set(PyObject *) {
15946 PyErr_SetString(PyExc_TypeError,"Variable ART_NEW_DIR is read-only.");
15947 return 1;
15948 }
15949
15950
15951 static PyObject *_wrap_ART_NEW_DIR_get(void) {
15952 PyObject *pyobj;
15953
15954 {
15955 #if wxUSE_UNICODE
15956 pyobj = PyUnicode_FromWideChar((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15957 #else
15958 pyobj = PyString_FromStringAndSize((&wxPyART_NEW_DIR)->c_str(), (&wxPyART_NEW_DIR)->Len());
15959 #endif
15960 }
15961 return pyobj;
15962 }
15963
15964
15965 static int _wrap_ART_HARDDISK_set(PyObject *) {
15966 PyErr_SetString(PyExc_TypeError,"Variable ART_HARDDISK is read-only.");
15967 return 1;
15968 }
15969
15970
15971 static PyObject *_wrap_ART_HARDDISK_get(void) {
15972 PyObject *pyobj;
15973
15974 {
15975 #if wxUSE_UNICODE
15976 pyobj = PyUnicode_FromWideChar((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15977 #else
15978 pyobj = PyString_FromStringAndSize((&wxPyART_HARDDISK)->c_str(), (&wxPyART_HARDDISK)->Len());
15979 #endif
15980 }
15981 return pyobj;
15982 }
15983
15984
15985 static int _wrap_ART_FLOPPY_set(PyObject *) {
15986 PyErr_SetString(PyExc_TypeError,"Variable ART_FLOPPY is read-only.");
15987 return 1;
15988 }
15989
15990
15991 static PyObject *_wrap_ART_FLOPPY_get(void) {
15992 PyObject *pyobj;
15993
15994 {
15995 #if wxUSE_UNICODE
15996 pyobj = PyUnicode_FromWideChar((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15997 #else
15998 pyobj = PyString_FromStringAndSize((&wxPyART_FLOPPY)->c_str(), (&wxPyART_FLOPPY)->Len());
15999 #endif
16000 }
16001 return pyobj;
16002 }
16003
16004
16005 static int _wrap_ART_CDROM_set(PyObject *) {
16006 PyErr_SetString(PyExc_TypeError,"Variable ART_CDROM is read-only.");
16007 return 1;
16008 }
16009
16010
16011 static PyObject *_wrap_ART_CDROM_get(void) {
16012 PyObject *pyobj;
16013
16014 {
16015 #if wxUSE_UNICODE
16016 pyobj = PyUnicode_FromWideChar((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16017 #else
16018 pyobj = PyString_FromStringAndSize((&wxPyART_CDROM)->c_str(), (&wxPyART_CDROM)->Len());
16019 #endif
16020 }
16021 return pyobj;
16022 }
16023
16024
16025 static int _wrap_ART_REMOVABLE_set(PyObject *) {
16026 PyErr_SetString(PyExc_TypeError,"Variable ART_REMOVABLE is read-only.");
16027 return 1;
16028 }
16029
16030
16031 static PyObject *_wrap_ART_REMOVABLE_get(void) {
16032 PyObject *pyobj;
16033
16034 {
16035 #if wxUSE_UNICODE
16036 pyobj = PyUnicode_FromWideChar((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16037 #else
16038 pyobj = PyString_FromStringAndSize((&wxPyART_REMOVABLE)->c_str(), (&wxPyART_REMOVABLE)->Len());
16039 #endif
16040 }
16041 return pyobj;
16042 }
16043
16044
16045 static int _wrap_ART_FOLDER_set(PyObject *) {
16046 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER is read-only.");
16047 return 1;
16048 }
16049
16050
16051 static PyObject *_wrap_ART_FOLDER_get(void) {
16052 PyObject *pyobj;
16053
16054 {
16055 #if wxUSE_UNICODE
16056 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16057 #else
16058 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER)->c_str(), (&wxPyART_FOLDER)->Len());
16059 #endif
16060 }
16061 return pyobj;
16062 }
16063
16064
16065 static int _wrap_ART_FOLDER_OPEN_set(PyObject *) {
16066 PyErr_SetString(PyExc_TypeError,"Variable ART_FOLDER_OPEN is read-only.");
16067 return 1;
16068 }
16069
16070
16071 static PyObject *_wrap_ART_FOLDER_OPEN_get(void) {
16072 PyObject *pyobj;
16073
16074 {
16075 #if wxUSE_UNICODE
16076 pyobj = PyUnicode_FromWideChar((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16077 #else
16078 pyobj = PyString_FromStringAndSize((&wxPyART_FOLDER_OPEN)->c_str(), (&wxPyART_FOLDER_OPEN)->Len());
16079 #endif
16080 }
16081 return pyobj;
16082 }
16083
16084
16085 static int _wrap_ART_GO_DIR_UP_set(PyObject *) {
16086 PyErr_SetString(PyExc_TypeError,"Variable ART_GO_DIR_UP is read-only.");
16087 return 1;
16088 }
16089
16090
16091 static PyObject *_wrap_ART_GO_DIR_UP_get(void) {
16092 PyObject *pyobj;
16093
16094 {
16095 #if wxUSE_UNICODE
16096 pyobj = PyUnicode_FromWideChar((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16097 #else
16098 pyobj = PyString_FromStringAndSize((&wxPyART_GO_DIR_UP)->c_str(), (&wxPyART_GO_DIR_UP)->Len());
16099 #endif
16100 }
16101 return pyobj;
16102 }
16103
16104
16105 static int _wrap_ART_EXECUTABLE_FILE_set(PyObject *) {
16106 PyErr_SetString(PyExc_TypeError,"Variable ART_EXECUTABLE_FILE is read-only.");
16107 return 1;
16108 }
16109
16110
16111 static PyObject *_wrap_ART_EXECUTABLE_FILE_get(void) {
16112 PyObject *pyobj;
16113
16114 {
16115 #if wxUSE_UNICODE
16116 pyobj = PyUnicode_FromWideChar((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16117 #else
16118 pyobj = PyString_FromStringAndSize((&wxPyART_EXECUTABLE_FILE)->c_str(), (&wxPyART_EXECUTABLE_FILE)->Len());
16119 #endif
16120 }
16121 return pyobj;
16122 }
16123
16124
16125 static int _wrap_ART_NORMAL_FILE_set(PyObject *) {
16126 PyErr_SetString(PyExc_TypeError,"Variable ART_NORMAL_FILE is read-only.");
16127 return 1;
16128 }
16129
16130
16131 static PyObject *_wrap_ART_NORMAL_FILE_get(void) {
16132 PyObject *pyobj;
16133
16134 {
16135 #if wxUSE_UNICODE
16136 pyobj = PyUnicode_FromWideChar((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16137 #else
16138 pyobj = PyString_FromStringAndSize((&wxPyART_NORMAL_FILE)->c_str(), (&wxPyART_NORMAL_FILE)->Len());
16139 #endif
16140 }
16141 return pyobj;
16142 }
16143
16144
16145 static int _wrap_ART_TICK_MARK_set(PyObject *) {
16146 PyErr_SetString(PyExc_TypeError,"Variable ART_TICK_MARK is read-only.");
16147 return 1;
16148 }
16149
16150
16151 static PyObject *_wrap_ART_TICK_MARK_get(void) {
16152 PyObject *pyobj;
16153
16154 {
16155 #if wxUSE_UNICODE
16156 pyobj = PyUnicode_FromWideChar((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16157 #else
16158 pyobj = PyString_FromStringAndSize((&wxPyART_TICK_MARK)->c_str(), (&wxPyART_TICK_MARK)->Len());
16159 #endif
16160 }
16161 return pyobj;
16162 }
16163
16164
16165 static int _wrap_ART_CROSS_MARK_set(PyObject *) {
16166 PyErr_SetString(PyExc_TypeError,"Variable ART_CROSS_MARK is read-only.");
16167 return 1;
16168 }
16169
16170
16171 static PyObject *_wrap_ART_CROSS_MARK_get(void) {
16172 PyObject *pyobj;
16173
16174 {
16175 #if wxUSE_UNICODE
16176 pyobj = PyUnicode_FromWideChar((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16177 #else
16178 pyobj = PyString_FromStringAndSize((&wxPyART_CROSS_MARK)->c_str(), (&wxPyART_CROSS_MARK)->Len());
16179 #endif
16180 }
16181 return pyobj;
16182 }
16183
16184
16185 static int _wrap_ART_ERROR_set(PyObject *) {
16186 PyErr_SetString(PyExc_TypeError,"Variable ART_ERROR is read-only.");
16187 return 1;
16188 }
16189
16190
16191 static PyObject *_wrap_ART_ERROR_get(void) {
16192 PyObject *pyobj;
16193
16194 {
16195 #if wxUSE_UNICODE
16196 pyobj = PyUnicode_FromWideChar((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16197 #else
16198 pyobj = PyString_FromStringAndSize((&wxPyART_ERROR)->c_str(), (&wxPyART_ERROR)->Len());
16199 #endif
16200 }
16201 return pyobj;
16202 }
16203
16204
16205 static int _wrap_ART_QUESTION_set(PyObject *) {
16206 PyErr_SetString(PyExc_TypeError,"Variable ART_QUESTION is read-only.");
16207 return 1;
16208 }
16209
16210
16211 static PyObject *_wrap_ART_QUESTION_get(void) {
16212 PyObject *pyobj;
16213
16214 {
16215 #if wxUSE_UNICODE
16216 pyobj = PyUnicode_FromWideChar((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16217 #else
16218 pyobj = PyString_FromStringAndSize((&wxPyART_QUESTION)->c_str(), (&wxPyART_QUESTION)->Len());
16219 #endif
16220 }
16221 return pyobj;
16222 }
16223
16224
16225 static int _wrap_ART_WARNING_set(PyObject *) {
16226 PyErr_SetString(PyExc_TypeError,"Variable ART_WARNING is read-only.");
16227 return 1;
16228 }
16229
16230
16231 static PyObject *_wrap_ART_WARNING_get(void) {
16232 PyObject *pyobj;
16233
16234 {
16235 #if wxUSE_UNICODE
16236 pyobj = PyUnicode_FromWideChar((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16237 #else
16238 pyobj = PyString_FromStringAndSize((&wxPyART_WARNING)->c_str(), (&wxPyART_WARNING)->Len());
16239 #endif
16240 }
16241 return pyobj;
16242 }
16243
16244
16245 static int _wrap_ART_INFORMATION_set(PyObject *) {
16246 PyErr_SetString(PyExc_TypeError,"Variable ART_INFORMATION is read-only.");
16247 return 1;
16248 }
16249
16250
16251 static PyObject *_wrap_ART_INFORMATION_get(void) {
16252 PyObject *pyobj;
16253
16254 {
16255 #if wxUSE_UNICODE
16256 pyobj = PyUnicode_FromWideChar((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16257 #else
16258 pyobj = PyString_FromStringAndSize((&wxPyART_INFORMATION)->c_str(), (&wxPyART_INFORMATION)->Len());
16259 #endif
16260 }
16261 return pyobj;
16262 }
16263
16264
16265 static int _wrap_ART_MISSING_IMAGE_set(PyObject *) {
16266 PyErr_SetString(PyExc_TypeError,"Variable ART_MISSING_IMAGE is read-only.");
16267 return 1;
16268 }
16269
16270
16271 static PyObject *_wrap_ART_MISSING_IMAGE_get(void) {
16272 PyObject *pyobj;
16273
16274 {
16275 #if wxUSE_UNICODE
16276 pyobj = PyUnicode_FromWideChar((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16277 #else
16278 pyobj = PyString_FromStringAndSize((&wxPyART_MISSING_IMAGE)->c_str(), (&wxPyART_MISSING_IMAGE)->Len());
16279 #endif
16280 }
16281 return pyobj;
16282 }
16283
16284
16285 static int _wrap_ART_COPY_set(PyObject *) {
16286 PyErr_SetString(PyExc_TypeError,"Variable ART_COPY is read-only.");
16287 return 1;
16288 }
16289
16290
16291 static PyObject *_wrap_ART_COPY_get(void) {
16292 PyObject *pyobj;
16293
16294 {
16295 #if wxUSE_UNICODE
16296 pyobj = PyUnicode_FromWideChar((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16297 #else
16298 pyobj = PyString_FromStringAndSize((&wxPyART_COPY)->c_str(), (&wxPyART_COPY)->Len());
16299 #endif
16300 }
16301 return pyobj;
16302 }
16303
16304
16305 static int _wrap_ART_CUT_set(PyObject *) {
16306 PyErr_SetString(PyExc_TypeError,"Variable ART_CUT is read-only.");
16307 return 1;
16308 }
16309
16310
16311 static PyObject *_wrap_ART_CUT_get(void) {
16312 PyObject *pyobj;
16313
16314 {
16315 #if wxUSE_UNICODE
16316 pyobj = PyUnicode_FromWideChar((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16317 #else
16318 pyobj = PyString_FromStringAndSize((&wxPyART_CUT)->c_str(), (&wxPyART_CUT)->Len());
16319 #endif
16320 }
16321 return pyobj;
16322 }
16323
16324
16325 static int _wrap_ART_PASTE_set(PyObject *) {
16326 PyErr_SetString(PyExc_TypeError,"Variable ART_PASTE is read-only.");
16327 return 1;
16328 }
16329
16330
16331 static PyObject *_wrap_ART_PASTE_get(void) {
16332 PyObject *pyobj;
16333
16334 {
16335 #if wxUSE_UNICODE
16336 pyobj = PyUnicode_FromWideChar((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16337 #else
16338 pyobj = PyString_FromStringAndSize((&wxPyART_PASTE)->c_str(), (&wxPyART_PASTE)->Len());
16339 #endif
16340 }
16341 return pyobj;
16342 }
16343
16344
16345 static int _wrap_ART_DELETE_set(PyObject *) {
16346 PyErr_SetString(PyExc_TypeError,"Variable ART_DELETE is read-only.");
16347 return 1;
16348 }
16349
16350
16351 static PyObject *_wrap_ART_DELETE_get(void) {
16352 PyObject *pyobj;
16353
16354 {
16355 #if wxUSE_UNICODE
16356 pyobj = PyUnicode_FromWideChar((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16357 #else
16358 pyobj = PyString_FromStringAndSize((&wxPyART_DELETE)->c_str(), (&wxPyART_DELETE)->Len());
16359 #endif
16360 }
16361 return pyobj;
16362 }
16363
16364
16365 static int _wrap_ART_UNDO_set(PyObject *) {
16366 PyErr_SetString(PyExc_TypeError,"Variable ART_UNDO is read-only.");
16367 return 1;
16368 }
16369
16370
16371 static PyObject *_wrap_ART_UNDO_get(void) {
16372 PyObject *pyobj;
16373
16374 {
16375 #if wxUSE_UNICODE
16376 pyobj = PyUnicode_FromWideChar((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16377 #else
16378 pyobj = PyString_FromStringAndSize((&wxPyART_UNDO)->c_str(), (&wxPyART_UNDO)->Len());
16379 #endif
16380 }
16381 return pyobj;
16382 }
16383
16384
16385 static int _wrap_ART_REDO_set(PyObject *) {
16386 PyErr_SetString(PyExc_TypeError,"Variable ART_REDO is read-only.");
16387 return 1;
16388 }
16389
16390
16391 static PyObject *_wrap_ART_REDO_get(void) {
16392 PyObject *pyobj;
16393
16394 {
16395 #if wxUSE_UNICODE
16396 pyobj = PyUnicode_FromWideChar((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16397 #else
16398 pyobj = PyString_FromStringAndSize((&wxPyART_REDO)->c_str(), (&wxPyART_REDO)->Len());
16399 #endif
16400 }
16401 return pyobj;
16402 }
16403
16404
16405 static int _wrap_ART_QUIT_set(PyObject *) {
16406 PyErr_SetString(PyExc_TypeError,"Variable ART_QUIT is read-only.");
16407 return 1;
16408 }
16409
16410
16411 static PyObject *_wrap_ART_QUIT_get(void) {
16412 PyObject *pyobj;
16413
16414 {
16415 #if wxUSE_UNICODE
16416 pyobj = PyUnicode_FromWideChar((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16417 #else
16418 pyobj = PyString_FromStringAndSize((&wxPyART_QUIT)->c_str(), (&wxPyART_QUIT)->Len());
16419 #endif
16420 }
16421 return pyobj;
16422 }
16423
16424
16425 static int _wrap_ART_FIND_set(PyObject *) {
16426 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND is read-only.");
16427 return 1;
16428 }
16429
16430
16431 static PyObject *_wrap_ART_FIND_get(void) {
16432 PyObject *pyobj;
16433
16434 {
16435 #if wxUSE_UNICODE
16436 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16437 #else
16438 pyobj = PyString_FromStringAndSize((&wxPyART_FIND)->c_str(), (&wxPyART_FIND)->Len());
16439 #endif
16440 }
16441 return pyobj;
16442 }
16443
16444
16445 static int _wrap_ART_FIND_AND_REPLACE_set(PyObject *) {
16446 PyErr_SetString(PyExc_TypeError,"Variable ART_FIND_AND_REPLACE is read-only.");
16447 return 1;
16448 }
16449
16450
16451 static PyObject *_wrap_ART_FIND_AND_REPLACE_get(void) {
16452 PyObject *pyobj;
16453
16454 {
16455 #if wxUSE_UNICODE
16456 pyobj = PyUnicode_FromWideChar((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16457 #else
16458 pyobj = PyString_FromStringAndSize((&wxPyART_FIND_AND_REPLACE)->c_str(), (&wxPyART_FIND_AND_REPLACE)->Len());
16459 #endif
16460 }
16461 return pyobj;
16462 }
16463
16464
16465 static PyObject *_wrap_new_ArtProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16466 PyObject *resultobj;
16467 wxPyArtProvider *result;
16468 char *kwnames[] = {
16469 NULL
16470 };
16471
16472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ArtProvider",kwnames)) goto fail;
16473 {
16474 if (!wxPyCheckForApp()) SWIG_fail;
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 result = (wxPyArtProvider *)new wxPyArtProvider();
16477
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyArtProvider, 1);
16482 return resultobj;
16483 fail:
16484 return NULL;
16485 }
16486
16487
16488 static PyObject *_wrap_ArtProvider__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
16489 PyObject *resultobj;
16490 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16491 PyObject *arg2 = (PyObject *) 0 ;
16492 PyObject *arg3 = (PyObject *) 0 ;
16493 PyObject * obj0 = 0 ;
16494 PyObject * obj1 = 0 ;
16495 PyObject * obj2 = 0 ;
16496 char *kwnames[] = {
16497 (char *) "self",(char *) "self",(char *) "_class", NULL
16498 };
16499
16500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ArtProvider__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
16501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16502 if (SWIG_arg_fail(1)) SWIG_fail;
16503 arg2 = obj1;
16504 arg3 = obj2;
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 (arg1)->_setCallbackInfo(arg2,arg3);
16508
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 Py_INCREF(Py_None); resultobj = Py_None;
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 static PyObject *_wrap_ArtProvider_PushProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj;
16521 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16522 PyObject * obj0 = 0 ;
16523 char *kwnames[] = {
16524 (char *) "provider", NULL
16525 };
16526
16527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_PushProvider",kwnames,&obj0)) goto fail;
16528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16529 if (SWIG_arg_fail(1)) SWIG_fail;
16530 {
16531 PyThreadState* __tstate = wxPyBeginAllowThreads();
16532 wxPyArtProvider::PushProvider(arg1);
16533
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 Py_INCREF(Py_None); resultobj = Py_None;
16538 return resultobj;
16539 fail:
16540 return NULL;
16541 }
16542
16543
16544 static PyObject *_wrap_ArtProvider_PopProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16545 PyObject *resultobj;
16546 bool result;
16547 char *kwnames[] = {
16548 NULL
16549 };
16550
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ArtProvider_PopProvider",kwnames)) goto fail;
16552 {
16553 PyThreadState* __tstate = wxPyBeginAllowThreads();
16554 result = (bool)wxPyArtProvider::PopProvider();
16555
16556 wxPyEndAllowThreads(__tstate);
16557 if (PyErr_Occurred()) SWIG_fail;
16558 }
16559 {
16560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16561 }
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_ArtProvider_RemoveProvider(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj;
16570 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16571 bool result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "provider", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_RemoveProvider",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = (bool)wxPyArtProvider::RemoveProvider(arg1);
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_ArtProvider_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj;
16598 wxString *arg1 = 0 ;
16599 wxString const &arg2_defvalue = wxPyART_OTHER ;
16600 wxString *arg2 = (wxString *) &arg2_defvalue ;
16601 wxSize const &arg3_defvalue = wxDefaultSize ;
16602 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16603 wxBitmap result;
16604 bool temp1 = false ;
16605 bool temp2 = false ;
16606 wxSize temp3 ;
16607 PyObject * obj0 = 0 ;
16608 PyObject * obj1 = 0 ;
16609 PyObject * obj2 = 0 ;
16610 char *kwnames[] = {
16611 (char *) "id",(char *) "client",(char *) "size", NULL
16612 };
16613
16614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
16615 {
16616 arg1 = wxString_in_helper(obj0);
16617 if (arg1 == NULL) SWIG_fail;
16618 temp1 = true;
16619 }
16620 if (obj1) {
16621 {
16622 arg2 = wxString_in_helper(obj1);
16623 if (arg2 == NULL) SWIG_fail;
16624 temp2 = true;
16625 }
16626 }
16627 if (obj2) {
16628 {
16629 arg3 = &temp3;
16630 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16631 }
16632 }
16633 {
16634 if (!wxPyCheckForApp()) SWIG_fail;
16635 PyThreadState* __tstate = wxPyBeginAllowThreads();
16636 result = wxPyArtProvider::GetBitmap((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16637
16638 wxPyEndAllowThreads(__tstate);
16639 if (PyErr_Occurred()) SWIG_fail;
16640 }
16641 {
16642 wxBitmap * resultptr;
16643 resultptr = new wxBitmap((wxBitmap &)(result));
16644 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
16645 }
16646 {
16647 if (temp1)
16648 delete arg1;
16649 }
16650 {
16651 if (temp2)
16652 delete arg2;
16653 }
16654 return resultobj;
16655 fail:
16656 {
16657 if (temp1)
16658 delete arg1;
16659 }
16660 {
16661 if (temp2)
16662 delete arg2;
16663 }
16664 return NULL;
16665 }
16666
16667
16668 static PyObject *_wrap_ArtProvider_GetIcon(PyObject *, PyObject *args, PyObject *kwargs) {
16669 PyObject *resultobj;
16670 wxString *arg1 = 0 ;
16671 wxString const &arg2_defvalue = wxPyART_OTHER ;
16672 wxString *arg2 = (wxString *) &arg2_defvalue ;
16673 wxSize const &arg3_defvalue = wxDefaultSize ;
16674 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
16675 wxIcon result;
16676 bool temp1 = false ;
16677 bool temp2 = false ;
16678 wxSize temp3 ;
16679 PyObject * obj0 = 0 ;
16680 PyObject * obj1 = 0 ;
16681 PyObject * obj2 = 0 ;
16682 char *kwnames[] = {
16683 (char *) "id",(char *) "client",(char *) "size", NULL
16684 };
16685
16686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:ArtProvider_GetIcon",kwnames,&obj0,&obj1,&obj2)) goto fail;
16687 {
16688 arg1 = wxString_in_helper(obj0);
16689 if (arg1 == NULL) SWIG_fail;
16690 temp1 = true;
16691 }
16692 if (obj1) {
16693 {
16694 arg2 = wxString_in_helper(obj1);
16695 if (arg2 == NULL) SWIG_fail;
16696 temp2 = true;
16697 }
16698 }
16699 if (obj2) {
16700 {
16701 arg3 = &temp3;
16702 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
16703 }
16704 }
16705 {
16706 if (!wxPyCheckForApp()) SWIG_fail;
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = wxPyArtProvider::GetIcon((wxString const &)*arg1,(wxString const &)*arg2,(wxSize const &)*arg3);
16709
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 {
16714 wxIcon * resultptr;
16715 resultptr = new wxIcon((wxIcon &)(result));
16716 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxIcon, 1);
16717 }
16718 {
16719 if (temp1)
16720 delete arg1;
16721 }
16722 {
16723 if (temp2)
16724 delete arg2;
16725 }
16726 return resultobj;
16727 fail:
16728 {
16729 if (temp1)
16730 delete arg1;
16731 }
16732 {
16733 if (temp2)
16734 delete arg2;
16735 }
16736 return NULL;
16737 }
16738
16739
16740 static PyObject *_wrap_ArtProvider_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
16741 PyObject *resultobj;
16742 wxString *arg1 = 0 ;
16743 bool arg2 = (bool) false ;
16744 wxSize result;
16745 bool temp1 = false ;
16746 PyObject * obj0 = 0 ;
16747 PyObject * obj1 = 0 ;
16748 char *kwnames[] = {
16749 (char *) "client",(char *) "platform_dependent", NULL
16750 };
16751
16752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ArtProvider_GetSize",kwnames,&obj0,&obj1)) goto fail;
16753 {
16754 arg1 = wxString_in_helper(obj0);
16755 if (arg1 == NULL) SWIG_fail;
16756 temp1 = true;
16757 }
16758 if (obj1) {
16759 {
16760 arg2 = (bool)(SWIG_As_bool(obj1));
16761 if (SWIG_arg_fail(2)) SWIG_fail;
16762 }
16763 }
16764 {
16765 PyThreadState* __tstate = wxPyBeginAllowThreads();
16766 result = wxPyArtProvider::GetSize((wxString const &)*arg1,arg2);
16767
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 {
16772 wxSize * resultptr;
16773 resultptr = new wxSize((wxSize &)(result));
16774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
16775 }
16776 {
16777 if (temp1)
16778 delete arg1;
16779 }
16780 return resultobj;
16781 fail:
16782 {
16783 if (temp1)
16784 delete arg1;
16785 }
16786 return NULL;
16787 }
16788
16789
16790 static PyObject *_wrap_ArtProvider_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
16791 PyObject *resultobj;
16792 wxPyArtProvider *arg1 = (wxPyArtProvider *) 0 ;
16793 PyObject * obj0 = 0 ;
16794 char *kwnames[] = {
16795 (char *) "self", NULL
16796 };
16797
16798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ArtProvider_Destroy",kwnames,&obj0)) goto fail;
16799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyArtProvider, SWIG_POINTER_EXCEPTION | 0);
16800 if (SWIG_arg_fail(1)) SWIG_fail;
16801 {
16802 PyThreadState* __tstate = wxPyBeginAllowThreads();
16803 wxPyArtProvider_Destroy(arg1);
16804
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 Py_INCREF(Py_None); resultobj = Py_None;
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 static PyObject * ArtProvider_swigregister(PyObject *, PyObject *args) {
16816 PyObject *obj;
16817 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16818 SWIG_TypeClientData(SWIGTYPE_p_wxPyArtProvider, obj);
16819 Py_INCREF(obj);
16820 return Py_BuildValue((char *)"");
16821 }
16822 static PyObject *_wrap_delete_ConfigBase(PyObject *, PyObject *args, PyObject *kwargs) {
16823 PyObject *resultobj;
16824 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16825 PyObject * obj0 = 0 ;
16826 char *kwnames[] = {
16827 (char *) "self", NULL
16828 };
16829
16830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigBase",kwnames,&obj0)) goto fail;
16831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16832 if (SWIG_arg_fail(1)) SWIG_fail;
16833 {
16834 PyThreadState* __tstate = wxPyBeginAllowThreads();
16835 delete arg1;
16836
16837 wxPyEndAllowThreads(__tstate);
16838 if (PyErr_Occurred()) SWIG_fail;
16839 }
16840 Py_INCREF(Py_None); resultobj = Py_None;
16841 return resultobj;
16842 fail:
16843 return NULL;
16844 }
16845
16846
16847 static PyObject *_wrap_ConfigBase_Set(PyObject *, PyObject *args, PyObject *kwargs) {
16848 PyObject *resultobj;
16849 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16850 wxConfigBase *result;
16851 PyObject * obj0 = 0 ;
16852 char *kwnames[] = {
16853 (char *) "config", NULL
16854 };
16855
16856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_Set",kwnames,&obj0)) goto fail;
16857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16858 if (SWIG_arg_fail(1)) SWIG_fail;
16859 {
16860 PyThreadState* __tstate = wxPyBeginAllowThreads();
16861 result = (wxConfigBase *)wxConfigBase::Set(arg1);
16862
16863 wxPyEndAllowThreads(__tstate);
16864 if (PyErr_Occurred()) SWIG_fail;
16865 }
16866 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16867 return resultobj;
16868 fail:
16869 return NULL;
16870 }
16871
16872
16873 static PyObject *_wrap_ConfigBase_Get(PyObject *, PyObject *args, PyObject *kwargs) {
16874 PyObject *resultobj;
16875 bool arg1 = (bool) true ;
16876 wxConfigBase *result;
16877 PyObject * obj0 = 0 ;
16878 char *kwnames[] = {
16879 (char *) "createOnDemand", NULL
16880 };
16881
16882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:ConfigBase_Get",kwnames,&obj0)) goto fail;
16883 if (obj0) {
16884 {
16885 arg1 = (bool)(SWIG_As_bool(obj0));
16886 if (SWIG_arg_fail(1)) SWIG_fail;
16887 }
16888 }
16889 {
16890 PyThreadState* __tstate = wxPyBeginAllowThreads();
16891 result = (wxConfigBase *)wxConfigBase::Get(arg1);
16892
16893 wxPyEndAllowThreads(__tstate);
16894 if (PyErr_Occurred()) SWIG_fail;
16895 }
16896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16897 return resultobj;
16898 fail:
16899 return NULL;
16900 }
16901
16902
16903 static PyObject *_wrap_ConfigBase_Create(PyObject *, PyObject *args, PyObject *kwargs) {
16904 PyObject *resultobj;
16905 wxConfigBase *result;
16906 char *kwnames[] = {
16907 NULL
16908 };
16909
16910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_Create",kwnames)) goto fail;
16911 {
16912 PyThreadState* __tstate = wxPyBeginAllowThreads();
16913 result = (wxConfigBase *)wxConfigBase::Create();
16914
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigBase, 0);
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 static PyObject *_wrap_ConfigBase_DontCreateOnDemand(PyObject *, PyObject *args, PyObject *kwargs) {
16926 PyObject *resultobj;
16927 char *kwnames[] = {
16928 NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":ConfigBase_DontCreateOnDemand",kwnames)) goto fail;
16932 {
16933 PyThreadState* __tstate = wxPyBeginAllowThreads();
16934 wxConfigBase::DontCreateOnDemand();
16935
16936 wxPyEndAllowThreads(__tstate);
16937 if (PyErr_Occurred()) SWIG_fail;
16938 }
16939 Py_INCREF(Py_None); resultobj = Py_None;
16940 return resultobj;
16941 fail:
16942 return NULL;
16943 }
16944
16945
16946 static PyObject *_wrap_ConfigBase_SetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16947 PyObject *resultobj;
16948 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16949 wxString *arg2 = 0 ;
16950 bool temp2 = false ;
16951 PyObject * obj0 = 0 ;
16952 PyObject * obj1 = 0 ;
16953 char *kwnames[] = {
16954 (char *) "self",(char *) "path", NULL
16955 };
16956
16957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetPath",kwnames,&obj0,&obj1)) goto fail;
16958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16959 if (SWIG_arg_fail(1)) SWIG_fail;
16960 {
16961 arg2 = wxString_in_helper(obj1);
16962 if (arg2 == NULL) SWIG_fail;
16963 temp2 = true;
16964 }
16965 {
16966 PyThreadState* __tstate = wxPyBeginAllowThreads();
16967 (arg1)->SetPath((wxString const &)*arg2);
16968
16969 wxPyEndAllowThreads(__tstate);
16970 if (PyErr_Occurred()) SWIG_fail;
16971 }
16972 Py_INCREF(Py_None); resultobj = Py_None;
16973 {
16974 if (temp2)
16975 delete arg2;
16976 }
16977 return resultobj;
16978 fail:
16979 {
16980 if (temp2)
16981 delete arg2;
16982 }
16983 return NULL;
16984 }
16985
16986
16987 static PyObject *_wrap_ConfigBase_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
16988 PyObject *resultobj;
16989 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
16990 wxString *result;
16991 PyObject * obj0 = 0 ;
16992 char *kwnames[] = {
16993 (char *) "self", NULL
16994 };
16995
16996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetPath",kwnames,&obj0)) goto fail;
16997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
16998 if (SWIG_arg_fail(1)) SWIG_fail;
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 {
17002 wxString const &_result_ref = ((wxConfigBase const *)arg1)->GetPath();
17003 result = (wxString *) &_result_ref;
17004 }
17005
17006 wxPyEndAllowThreads(__tstate);
17007 if (PyErr_Occurred()) SWIG_fail;
17008 }
17009 {
17010 #if wxUSE_UNICODE
17011 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
17012 #else
17013 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
17014 #endif
17015 }
17016 return resultobj;
17017 fail:
17018 return NULL;
17019 }
17020
17021
17022 static PyObject *_wrap_ConfigBase_GetFirstGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17023 PyObject *resultobj;
17024 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17025 PyObject *result;
17026 PyObject * obj0 = 0 ;
17027 char *kwnames[] = {
17028 (char *) "self", NULL
17029 };
17030
17031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstGroup",kwnames,&obj0)) goto fail;
17032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17033 if (SWIG_arg_fail(1)) SWIG_fail;
17034 {
17035 PyThreadState* __tstate = wxPyBeginAllowThreads();
17036 result = (PyObject *)wxConfigBase_GetFirstGroup(arg1);
17037
17038 wxPyEndAllowThreads(__tstate);
17039 if (PyErr_Occurred()) SWIG_fail;
17040 }
17041 resultobj = result;
17042 return resultobj;
17043 fail:
17044 return NULL;
17045 }
17046
17047
17048 static PyObject *_wrap_ConfigBase_GetNextGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17049 PyObject *resultobj;
17050 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17051 long arg2 ;
17052 PyObject *result;
17053 PyObject * obj0 = 0 ;
17054 PyObject * obj1 = 0 ;
17055 char *kwnames[] = {
17056 (char *) "self",(char *) "index", NULL
17057 };
17058
17059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextGroup",kwnames,&obj0,&obj1)) goto fail;
17060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17061 if (SWIG_arg_fail(1)) SWIG_fail;
17062 {
17063 arg2 = (long)(SWIG_As_long(obj1));
17064 if (SWIG_arg_fail(2)) SWIG_fail;
17065 }
17066 {
17067 PyThreadState* __tstate = wxPyBeginAllowThreads();
17068 result = (PyObject *)wxConfigBase_GetNextGroup(arg1,arg2);
17069
17070 wxPyEndAllowThreads(__tstate);
17071 if (PyErr_Occurred()) SWIG_fail;
17072 }
17073 resultobj = result;
17074 return resultobj;
17075 fail:
17076 return NULL;
17077 }
17078
17079
17080 static PyObject *_wrap_ConfigBase_GetFirstEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj;
17082 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17083 PyObject *result;
17084 PyObject * obj0 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetFirstEntry",kwnames,&obj0)) 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 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = (PyObject *)wxConfigBase_GetFirstEntry(arg1);
17095
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 resultobj = result;
17100 return resultobj;
17101 fail:
17102 return NULL;
17103 }
17104
17105
17106 static PyObject *_wrap_ConfigBase_GetNextEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17107 PyObject *resultobj;
17108 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17109 long arg2 ;
17110 PyObject *result;
17111 PyObject * obj0 = 0 ;
17112 PyObject * obj1 = 0 ;
17113 char *kwnames[] = {
17114 (char *) "self",(char *) "index", NULL
17115 };
17116
17117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetNextEntry",kwnames,&obj0,&obj1)) goto fail;
17118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17119 if (SWIG_arg_fail(1)) SWIG_fail;
17120 {
17121 arg2 = (long)(SWIG_As_long(obj1));
17122 if (SWIG_arg_fail(2)) SWIG_fail;
17123 }
17124 {
17125 PyThreadState* __tstate = wxPyBeginAllowThreads();
17126 result = (PyObject *)wxConfigBase_GetNextEntry(arg1,arg2);
17127
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 resultobj = result;
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 static PyObject *_wrap_ConfigBase_GetNumberOfEntries(PyObject *, PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj;
17140 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17141 bool arg2 = (bool) false ;
17142 size_t result;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 char *kwnames[] = {
17146 (char *) "self",(char *) "recursive", NULL
17147 };
17148
17149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfEntries",kwnames,&obj0,&obj1)) goto fail;
17150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17151 if (SWIG_arg_fail(1)) SWIG_fail;
17152 if (obj1) {
17153 {
17154 arg2 = (bool)(SWIG_As_bool(obj1));
17155 if (SWIG_arg_fail(2)) SWIG_fail;
17156 }
17157 }
17158 {
17159 PyThreadState* __tstate = wxPyBeginAllowThreads();
17160 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfEntries(arg2);
17161
17162 wxPyEndAllowThreads(__tstate);
17163 if (PyErr_Occurred()) SWIG_fail;
17164 }
17165 {
17166 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17167 }
17168 return resultobj;
17169 fail:
17170 return NULL;
17171 }
17172
17173
17174 static PyObject *_wrap_ConfigBase_GetNumberOfGroups(PyObject *, PyObject *args, PyObject *kwargs) {
17175 PyObject *resultobj;
17176 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17177 bool arg2 = (bool) false ;
17178 size_t result;
17179 PyObject * obj0 = 0 ;
17180 PyObject * obj1 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self",(char *) "recursive", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_GetNumberOfGroups",kwnames,&obj0,&obj1)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 if (obj1) {
17189 {
17190 arg2 = (bool)(SWIG_As_bool(obj1));
17191 if (SWIG_arg_fail(2)) SWIG_fail;
17192 }
17193 }
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (size_t)((wxConfigBase const *)arg1)->GetNumberOfGroups(arg2);
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_ConfigBase_HasGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17213 wxString *arg2 = 0 ;
17214 bool result;
17215 bool temp2 = false ;
17216 PyObject * obj0 = 0 ;
17217 PyObject * obj1 = 0 ;
17218 char *kwnames[] = {
17219 (char *) "self",(char *) "name", NULL
17220 };
17221
17222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasGroup",kwnames,&obj0,&obj1)) goto fail;
17223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17224 if (SWIG_arg_fail(1)) SWIG_fail;
17225 {
17226 arg2 = wxString_in_helper(obj1);
17227 if (arg2 == NULL) SWIG_fail;
17228 temp2 = true;
17229 }
17230 {
17231 PyThreadState* __tstate = wxPyBeginAllowThreads();
17232 result = (bool)((wxConfigBase const *)arg1)->HasGroup((wxString const &)*arg2);
17233
17234 wxPyEndAllowThreads(__tstate);
17235 if (PyErr_Occurred()) SWIG_fail;
17236 }
17237 {
17238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17239 }
17240 {
17241 if (temp2)
17242 delete arg2;
17243 }
17244 return resultobj;
17245 fail:
17246 {
17247 if (temp2)
17248 delete arg2;
17249 }
17250 return NULL;
17251 }
17252
17253
17254 static PyObject *_wrap_ConfigBase_HasEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17255 PyObject *resultobj;
17256 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17257 wxString *arg2 = 0 ;
17258 bool result;
17259 bool temp2 = false ;
17260 PyObject * obj0 = 0 ;
17261 PyObject * obj1 = 0 ;
17262 char *kwnames[] = {
17263 (char *) "self",(char *) "name", NULL
17264 };
17265
17266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_HasEntry",kwnames,&obj0,&obj1)) goto fail;
17267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17268 if (SWIG_arg_fail(1)) SWIG_fail;
17269 {
17270 arg2 = wxString_in_helper(obj1);
17271 if (arg2 == NULL) SWIG_fail;
17272 temp2 = true;
17273 }
17274 {
17275 PyThreadState* __tstate = wxPyBeginAllowThreads();
17276 result = (bool)((wxConfigBase const *)arg1)->HasEntry((wxString const &)*arg2);
17277
17278 wxPyEndAllowThreads(__tstate);
17279 if (PyErr_Occurred()) SWIG_fail;
17280 }
17281 {
17282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17283 }
17284 {
17285 if (temp2)
17286 delete arg2;
17287 }
17288 return resultobj;
17289 fail:
17290 {
17291 if (temp2)
17292 delete arg2;
17293 }
17294 return NULL;
17295 }
17296
17297
17298 static PyObject *_wrap_ConfigBase_Exists(PyObject *, PyObject *args, PyObject *kwargs) {
17299 PyObject *resultobj;
17300 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17301 wxString *arg2 = 0 ;
17302 bool result;
17303 bool temp2 = false ;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self",(char *) "name", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_Exists",kwnames,&obj0,&obj1)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 {
17314 arg2 = wxString_in_helper(obj1);
17315 if (arg2 == NULL) SWIG_fail;
17316 temp2 = true;
17317 }
17318 {
17319 PyThreadState* __tstate = wxPyBeginAllowThreads();
17320 result = (bool)((wxConfigBase const *)arg1)->Exists((wxString const &)*arg2);
17321
17322 wxPyEndAllowThreads(__tstate);
17323 if (PyErr_Occurred()) SWIG_fail;
17324 }
17325 {
17326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17327 }
17328 {
17329 if (temp2)
17330 delete arg2;
17331 }
17332 return resultobj;
17333 fail:
17334 {
17335 if (temp2)
17336 delete arg2;
17337 }
17338 return NULL;
17339 }
17340
17341
17342 static PyObject *_wrap_ConfigBase_GetEntryType(PyObject *, PyObject *args, PyObject *kwargs) {
17343 PyObject *resultobj;
17344 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17345 wxString *arg2 = 0 ;
17346 wxConfigBase::EntryType result;
17347 bool temp2 = false ;
17348 PyObject * obj0 = 0 ;
17349 PyObject * obj1 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self",(char *) "name", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_GetEntryType",kwnames,&obj0,&obj1)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 {
17358 arg2 = wxString_in_helper(obj1);
17359 if (arg2 == NULL) SWIG_fail;
17360 temp2 = true;
17361 }
17362 {
17363 PyThreadState* __tstate = wxPyBeginAllowThreads();
17364 result = (wxConfigBase::EntryType)((wxConfigBase const *)arg1)->GetEntryType((wxString const &)*arg2);
17365
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 resultobj = SWIG_From_int((result));
17370 {
17371 if (temp2)
17372 delete arg2;
17373 }
17374 return resultobj;
17375 fail:
17376 {
17377 if (temp2)
17378 delete arg2;
17379 }
17380 return NULL;
17381 }
17382
17383
17384 static PyObject *_wrap_ConfigBase_Read(PyObject *, PyObject *args, PyObject *kwargs) {
17385 PyObject *resultobj;
17386 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17387 wxString *arg2 = 0 ;
17388 wxString const &arg3_defvalue = wxPyEmptyString ;
17389 wxString *arg3 = (wxString *) &arg3_defvalue ;
17390 wxString result;
17391 bool temp2 = false ;
17392 bool temp3 = false ;
17393 PyObject * obj0 = 0 ;
17394 PyObject * obj1 = 0 ;
17395 PyObject * obj2 = 0 ;
17396 char *kwnames[] = {
17397 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17398 };
17399
17400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_Read",kwnames,&obj0,&obj1,&obj2)) goto fail;
17401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17402 if (SWIG_arg_fail(1)) SWIG_fail;
17403 {
17404 arg2 = wxString_in_helper(obj1);
17405 if (arg2 == NULL) SWIG_fail;
17406 temp2 = true;
17407 }
17408 if (obj2) {
17409 {
17410 arg3 = wxString_in_helper(obj2);
17411 if (arg3 == NULL) SWIG_fail;
17412 temp3 = true;
17413 }
17414 }
17415 {
17416 PyThreadState* __tstate = wxPyBeginAllowThreads();
17417 result = (arg1)->Read((wxString const &)*arg2,(wxString const &)*arg3);
17418
17419 wxPyEndAllowThreads(__tstate);
17420 if (PyErr_Occurred()) SWIG_fail;
17421 }
17422 {
17423 #if wxUSE_UNICODE
17424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17425 #else
17426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17427 #endif
17428 }
17429 {
17430 if (temp2)
17431 delete arg2;
17432 }
17433 {
17434 if (temp3)
17435 delete arg3;
17436 }
17437 return resultobj;
17438 fail:
17439 {
17440 if (temp2)
17441 delete arg2;
17442 }
17443 {
17444 if (temp3)
17445 delete arg3;
17446 }
17447 return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_ConfigBase_ReadInt(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17454 wxString *arg2 = 0 ;
17455 long arg3 = (long) 0 ;
17456 long result;
17457 bool temp2 = false ;
17458 PyObject * obj0 = 0 ;
17459 PyObject * obj1 = 0 ;
17460 PyObject * obj2 = 0 ;
17461 char *kwnames[] = {
17462 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17463 };
17464
17465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17467 if (SWIG_arg_fail(1)) SWIG_fail;
17468 {
17469 arg2 = wxString_in_helper(obj1);
17470 if (arg2 == NULL) SWIG_fail;
17471 temp2 = true;
17472 }
17473 if (obj2) {
17474 {
17475 arg3 = (long)(SWIG_As_long(obj2));
17476 if (SWIG_arg_fail(3)) SWIG_fail;
17477 }
17478 }
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (long)wxConfigBase_ReadInt(arg1,(wxString const &)*arg2,arg3);
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = SWIG_From_long((long)(result));
17488 }
17489 {
17490 if (temp2)
17491 delete arg2;
17492 }
17493 return resultobj;
17494 fail:
17495 {
17496 if (temp2)
17497 delete arg2;
17498 }
17499 return NULL;
17500 }
17501
17502
17503 static PyObject *_wrap_ConfigBase_ReadFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17504 PyObject *resultobj;
17505 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17506 wxString *arg2 = 0 ;
17507 double arg3 = (double) 0.0 ;
17508 double result;
17509 bool temp2 = false ;
17510 PyObject * obj0 = 0 ;
17511 PyObject * obj1 = 0 ;
17512 PyObject * obj2 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 {
17521 arg2 = wxString_in_helper(obj1);
17522 if (arg2 == NULL) SWIG_fail;
17523 temp2 = true;
17524 }
17525 if (obj2) {
17526 {
17527 arg3 = (double)(SWIG_As_double(obj2));
17528 if (SWIG_arg_fail(3)) SWIG_fail;
17529 }
17530 }
17531 {
17532 PyThreadState* __tstate = wxPyBeginAllowThreads();
17533 result = (double)wxConfigBase_ReadFloat(arg1,(wxString const &)*arg2,arg3);
17534
17535 wxPyEndAllowThreads(__tstate);
17536 if (PyErr_Occurred()) SWIG_fail;
17537 }
17538 {
17539 resultobj = SWIG_From_double((double)(result));
17540 }
17541 {
17542 if (temp2)
17543 delete arg2;
17544 }
17545 return resultobj;
17546 fail:
17547 {
17548 if (temp2)
17549 delete arg2;
17550 }
17551 return NULL;
17552 }
17553
17554
17555 static PyObject *_wrap_ConfigBase_ReadBool(PyObject *, PyObject *args, PyObject *kwargs) {
17556 PyObject *resultobj;
17557 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17558 wxString *arg2 = 0 ;
17559 bool arg3 = (bool) false ;
17560 bool result;
17561 bool temp2 = false ;
17562 PyObject * obj0 = 0 ;
17563 PyObject * obj1 = 0 ;
17564 PyObject * obj2 = 0 ;
17565 char *kwnames[] = {
17566 (char *) "self",(char *) "key",(char *) "defaultVal", NULL
17567 };
17568
17569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_ReadBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17571 if (SWIG_arg_fail(1)) SWIG_fail;
17572 {
17573 arg2 = wxString_in_helper(obj1);
17574 if (arg2 == NULL) SWIG_fail;
17575 temp2 = true;
17576 }
17577 if (obj2) {
17578 {
17579 arg3 = (bool)(SWIG_As_bool(obj2));
17580 if (SWIG_arg_fail(3)) SWIG_fail;
17581 }
17582 }
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (bool)wxConfigBase_ReadBool(arg1,(wxString const &)*arg2,arg3);
17586
17587 wxPyEndAllowThreads(__tstate);
17588 if (PyErr_Occurred()) SWIG_fail;
17589 }
17590 {
17591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17592 }
17593 {
17594 if (temp2)
17595 delete arg2;
17596 }
17597 return resultobj;
17598 fail:
17599 {
17600 if (temp2)
17601 delete arg2;
17602 }
17603 return NULL;
17604 }
17605
17606
17607 static PyObject *_wrap_ConfigBase_Write(PyObject *, PyObject *args, PyObject *kwargs) {
17608 PyObject *resultobj;
17609 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17610 wxString *arg2 = 0 ;
17611 wxString *arg3 = 0 ;
17612 bool result;
17613 bool temp2 = false ;
17614 bool temp3 = false ;
17615 PyObject * obj0 = 0 ;
17616 PyObject * obj1 = 0 ;
17617 PyObject * obj2 = 0 ;
17618 char *kwnames[] = {
17619 (char *) "self",(char *) "key",(char *) "value", NULL
17620 };
17621
17622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_Write",kwnames,&obj0,&obj1,&obj2)) goto fail;
17623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17624 if (SWIG_arg_fail(1)) SWIG_fail;
17625 {
17626 arg2 = wxString_in_helper(obj1);
17627 if (arg2 == NULL) SWIG_fail;
17628 temp2 = true;
17629 }
17630 {
17631 arg3 = wxString_in_helper(obj2);
17632 if (arg3 == NULL) SWIG_fail;
17633 temp3 = true;
17634 }
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (bool)(arg1)->Write((wxString const &)*arg2,(wxString const &)*arg3);
17638
17639 wxPyEndAllowThreads(__tstate);
17640 if (PyErr_Occurred()) SWIG_fail;
17641 }
17642 {
17643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17644 }
17645 {
17646 if (temp2)
17647 delete arg2;
17648 }
17649 {
17650 if (temp3)
17651 delete arg3;
17652 }
17653 return resultobj;
17654 fail:
17655 {
17656 if (temp2)
17657 delete arg2;
17658 }
17659 {
17660 if (temp3)
17661 delete arg3;
17662 }
17663 return NULL;
17664 }
17665
17666
17667 static PyObject *_wrap_ConfigBase_WriteInt(PyObject *, PyObject *args, PyObject *kwargs) {
17668 PyObject *resultobj;
17669 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17670 wxString *arg2 = 0 ;
17671 long arg3 ;
17672 bool result;
17673 bool temp2 = false ;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 PyObject * obj2 = 0 ;
17677 char *kwnames[] = {
17678 (char *) "self",(char *) "key",(char *) "value", NULL
17679 };
17680
17681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
17682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17683 if (SWIG_arg_fail(1)) SWIG_fail;
17684 {
17685 arg2 = wxString_in_helper(obj1);
17686 if (arg2 == NULL) SWIG_fail;
17687 temp2 = true;
17688 }
17689 {
17690 arg3 = (long)(SWIG_As_long(obj2));
17691 if (SWIG_arg_fail(3)) SWIG_fail;
17692 }
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17702 }
17703 {
17704 if (temp2)
17705 delete arg2;
17706 }
17707 return resultobj;
17708 fail:
17709 {
17710 if (temp2)
17711 delete arg2;
17712 }
17713 return NULL;
17714 }
17715
17716
17717 static PyObject *_wrap_ConfigBase_WriteFloat(PyObject *, PyObject *args, PyObject *kwargs) {
17718 PyObject *resultobj;
17719 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17720 wxString *arg2 = 0 ;
17721 double arg3 ;
17722 bool result;
17723 bool temp2 = false ;
17724 PyObject * obj0 = 0 ;
17725 PyObject * obj1 = 0 ;
17726 PyObject * obj2 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self",(char *) "key",(char *) "value", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteFloat",kwnames,&obj0,&obj1,&obj2)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 arg2 = wxString_in_helper(obj1);
17736 if (arg2 == NULL) SWIG_fail;
17737 temp2 = true;
17738 }
17739 {
17740 arg3 = (double)(SWIG_As_double(obj2));
17741 if (SWIG_arg_fail(3)) SWIG_fail;
17742 }
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17746
17747 wxPyEndAllowThreads(__tstate);
17748 if (PyErr_Occurred()) SWIG_fail;
17749 }
17750 {
17751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17752 }
17753 {
17754 if (temp2)
17755 delete arg2;
17756 }
17757 return resultobj;
17758 fail:
17759 {
17760 if (temp2)
17761 delete arg2;
17762 }
17763 return NULL;
17764 }
17765
17766
17767 static PyObject *_wrap_ConfigBase_WriteBool(PyObject *, PyObject *args, PyObject *kwargs) {
17768 PyObject *resultobj;
17769 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17770 wxString *arg2 = 0 ;
17771 bool arg3 ;
17772 bool result;
17773 bool temp2 = false ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 PyObject * obj2 = 0 ;
17777 char *kwnames[] = {
17778 (char *) "self",(char *) "key",(char *) "value", NULL
17779 };
17780
17781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_WriteBool",kwnames,&obj0,&obj1,&obj2)) goto fail;
17782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17783 if (SWIG_arg_fail(1)) SWIG_fail;
17784 {
17785 arg2 = wxString_in_helper(obj1);
17786 if (arg2 == NULL) SWIG_fail;
17787 temp2 = true;
17788 }
17789 {
17790 arg3 = (bool)(SWIG_As_bool(obj2));
17791 if (SWIG_arg_fail(3)) SWIG_fail;
17792 }
17793 {
17794 PyThreadState* __tstate = wxPyBeginAllowThreads();
17795 result = (bool)(arg1)->Write((wxString const &)*arg2,arg3);
17796
17797 wxPyEndAllowThreads(__tstate);
17798 if (PyErr_Occurred()) SWIG_fail;
17799 }
17800 {
17801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17802 }
17803 {
17804 if (temp2)
17805 delete arg2;
17806 }
17807 return resultobj;
17808 fail:
17809 {
17810 if (temp2)
17811 delete arg2;
17812 }
17813 return NULL;
17814 }
17815
17816
17817 static PyObject *_wrap_ConfigBase_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj;
17819 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17820 bool arg2 = (bool) false ;
17821 bool result;
17822 PyObject * obj0 = 0 ;
17823 PyObject * obj1 = 0 ;
17824 char *kwnames[] = {
17825 (char *) "self",(char *) "currentOnly", NULL
17826 };
17827
17828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_Flush",kwnames,&obj0,&obj1)) goto fail;
17829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17830 if (SWIG_arg_fail(1)) SWIG_fail;
17831 if (obj1) {
17832 {
17833 arg2 = (bool)(SWIG_As_bool(obj1));
17834 if (SWIG_arg_fail(2)) SWIG_fail;
17835 }
17836 }
17837 {
17838 PyThreadState* __tstate = wxPyBeginAllowThreads();
17839 result = (bool)(arg1)->Flush(arg2);
17840
17841 wxPyEndAllowThreads(__tstate);
17842 if (PyErr_Occurred()) SWIG_fail;
17843 }
17844 {
17845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17846 }
17847 return resultobj;
17848 fail:
17849 return NULL;
17850 }
17851
17852
17853 static PyObject *_wrap_ConfigBase_RenameEntry(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_RenameEntry",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)->RenameEntry((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_RenameGroup(PyObject *, PyObject *args, PyObject *kwargs) {
17914 PyObject *resultobj;
17915 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17916 wxString *arg2 = 0 ;
17917 wxString *arg3 = 0 ;
17918 bool result;
17919 bool temp2 = false ;
17920 bool temp3 = false ;
17921 PyObject * obj0 = 0 ;
17922 PyObject * obj1 = 0 ;
17923 PyObject * obj2 = 0 ;
17924 char *kwnames[] = {
17925 (char *) "self",(char *) "oldName",(char *) "newName", NULL
17926 };
17927
17928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ConfigBase_RenameGroup",kwnames,&obj0,&obj1,&obj2)) goto fail;
17929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17930 if (SWIG_arg_fail(1)) SWIG_fail;
17931 {
17932 arg2 = wxString_in_helper(obj1);
17933 if (arg2 == NULL) SWIG_fail;
17934 temp2 = true;
17935 }
17936 {
17937 arg3 = wxString_in_helper(obj2);
17938 if (arg3 == NULL) SWIG_fail;
17939 temp3 = true;
17940 }
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (bool)(arg1)->RenameGroup((wxString const &)*arg2,(wxString const &)*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 {
17956 if (temp3)
17957 delete arg3;
17958 }
17959 return resultobj;
17960 fail:
17961 {
17962 if (temp2)
17963 delete arg2;
17964 }
17965 {
17966 if (temp3)
17967 delete arg3;
17968 }
17969 return NULL;
17970 }
17971
17972
17973 static PyObject *_wrap_ConfigBase_DeleteEntry(PyObject *, PyObject *args, PyObject *kwargs) {
17974 PyObject *resultobj;
17975 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
17976 wxString *arg2 = 0 ;
17977 bool arg3 = (bool) true ;
17978 bool result;
17979 bool temp2 = false ;
17980 PyObject * obj0 = 0 ;
17981 PyObject * obj1 = 0 ;
17982 PyObject * obj2 = 0 ;
17983 char *kwnames[] = {
17984 (char *) "self",(char *) "key",(char *) "deleteGroupIfEmpty", NULL
17985 };
17986
17987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ConfigBase_DeleteEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
17988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
17989 if (SWIG_arg_fail(1)) SWIG_fail;
17990 {
17991 arg2 = wxString_in_helper(obj1);
17992 if (arg2 == NULL) SWIG_fail;
17993 temp2 = true;
17994 }
17995 if (obj2) {
17996 {
17997 arg3 = (bool)(SWIG_As_bool(obj2));
17998 if (SWIG_arg_fail(3)) SWIG_fail;
17999 }
18000 }
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 result = (bool)(arg1)->DeleteEntry((wxString const &)*arg2,arg3);
18004
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 {
18009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18010 }
18011 {
18012 if (temp2)
18013 delete arg2;
18014 }
18015 return resultobj;
18016 fail:
18017 {
18018 if (temp2)
18019 delete arg2;
18020 }
18021 return NULL;
18022 }
18023
18024
18025 static PyObject *_wrap_ConfigBase_DeleteGroup(PyObject *, PyObject *args, PyObject *kwargs) {
18026 PyObject *resultobj;
18027 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18028 wxString *arg2 = 0 ;
18029 bool result;
18030 bool temp2 = false ;
18031 PyObject * obj0 = 0 ;
18032 PyObject * obj1 = 0 ;
18033 char *kwnames[] = {
18034 (char *) "self",(char *) "key", NULL
18035 };
18036
18037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_DeleteGroup",kwnames,&obj0,&obj1)) goto fail;
18038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18039 if (SWIG_arg_fail(1)) SWIG_fail;
18040 {
18041 arg2 = wxString_in_helper(obj1);
18042 if (arg2 == NULL) SWIG_fail;
18043 temp2 = true;
18044 }
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (bool)(arg1)->DeleteGroup((wxString const &)*arg2);
18048
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18054 }
18055 {
18056 if (temp2)
18057 delete arg2;
18058 }
18059 return resultobj;
18060 fail:
18061 {
18062 if (temp2)
18063 delete arg2;
18064 }
18065 return NULL;
18066 }
18067
18068
18069 static PyObject *_wrap_ConfigBase_DeleteAll(PyObject *, PyObject *args, PyObject *kwargs) {
18070 PyObject *resultobj;
18071 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18072 bool result;
18073 PyObject * obj0 = 0 ;
18074 char *kwnames[] = {
18075 (char *) "self", NULL
18076 };
18077
18078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_DeleteAll",kwnames,&obj0)) goto fail;
18079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18080 if (SWIG_arg_fail(1)) SWIG_fail;
18081 {
18082 PyThreadState* __tstate = wxPyBeginAllowThreads();
18083 result = (bool)(arg1)->DeleteAll();
18084
18085 wxPyEndAllowThreads(__tstate);
18086 if (PyErr_Occurred()) SWIG_fail;
18087 }
18088 {
18089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18090 }
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 static PyObject *_wrap_ConfigBase_SetExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18098 PyObject *resultobj;
18099 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18100 bool arg2 = (bool) true ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 char *kwnames[] = {
18104 (char *) "self",(char *) "doIt", NULL
18105 };
18106
18107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18109 if (SWIG_arg_fail(1)) SWIG_fail;
18110 if (obj1) {
18111 {
18112 arg2 = (bool)(SWIG_As_bool(obj1));
18113 if (SWIG_arg_fail(2)) SWIG_fail;
18114 }
18115 }
18116 {
18117 PyThreadState* __tstate = wxPyBeginAllowThreads();
18118 (arg1)->SetExpandEnvVars(arg2);
18119
18120 wxPyEndAllowThreads(__tstate);
18121 if (PyErr_Occurred()) SWIG_fail;
18122 }
18123 Py_INCREF(Py_None); resultobj = Py_None;
18124 return resultobj;
18125 fail:
18126 return NULL;
18127 }
18128
18129
18130 static PyObject *_wrap_ConfigBase_IsExpandingEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18131 PyObject *resultobj;
18132 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18133 bool result;
18134 PyObject * obj0 = 0 ;
18135 char *kwnames[] = {
18136 (char *) "self", NULL
18137 };
18138
18139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsExpandingEnvVars",kwnames,&obj0)) goto fail;
18140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18141 if (SWIG_arg_fail(1)) SWIG_fail;
18142 {
18143 PyThreadState* __tstate = wxPyBeginAllowThreads();
18144 result = (bool)((wxConfigBase const *)arg1)->IsExpandingEnvVars();
18145
18146 wxPyEndAllowThreads(__tstate);
18147 if (PyErr_Occurred()) SWIG_fail;
18148 }
18149 {
18150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18151 }
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 static PyObject *_wrap_ConfigBase_SetRecordDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj;
18160 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18161 bool arg2 = (bool) true ;
18162 PyObject * obj0 = 0 ;
18163 PyObject * obj1 = 0 ;
18164 char *kwnames[] = {
18165 (char *) "self",(char *) "doIt", NULL
18166 };
18167
18168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:ConfigBase_SetRecordDefaults",kwnames,&obj0,&obj1)) goto fail;
18169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18170 if (SWIG_arg_fail(1)) SWIG_fail;
18171 if (obj1) {
18172 {
18173 arg2 = (bool)(SWIG_As_bool(obj1));
18174 if (SWIG_arg_fail(2)) SWIG_fail;
18175 }
18176 }
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 (arg1)->SetRecordDefaults(arg2);
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 Py_INCREF(Py_None); resultobj = Py_None;
18185 return resultobj;
18186 fail:
18187 return NULL;
18188 }
18189
18190
18191 static PyObject *_wrap_ConfigBase_IsRecordingDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
18192 PyObject *resultobj;
18193 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18194 bool result;
18195 PyObject * obj0 = 0 ;
18196 char *kwnames[] = {
18197 (char *) "self", NULL
18198 };
18199
18200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_IsRecordingDefaults",kwnames,&obj0)) goto fail;
18201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18202 if (SWIG_arg_fail(1)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (bool)((wxConfigBase const *)arg1)->IsRecordingDefaults();
18206
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 {
18211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18212 }
18213 return resultobj;
18214 fail:
18215 return NULL;
18216 }
18217
18218
18219 static PyObject *_wrap_ConfigBase_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18220 PyObject *resultobj;
18221 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18222 wxString *arg2 = 0 ;
18223 wxString result;
18224 bool temp2 = false ;
18225 PyObject * obj0 = 0 ;
18226 PyObject * obj1 = 0 ;
18227 char *kwnames[] = {
18228 (char *) "self",(char *) "str", NULL
18229 };
18230
18231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_ExpandEnvVars",kwnames,&obj0,&obj1)) goto fail;
18232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18233 if (SWIG_arg_fail(1)) SWIG_fail;
18234 {
18235 arg2 = wxString_in_helper(obj1);
18236 if (arg2 == NULL) SWIG_fail;
18237 temp2 = true;
18238 }
18239 {
18240 PyThreadState* __tstate = wxPyBeginAllowThreads();
18241 result = ((wxConfigBase const *)arg1)->ExpandEnvVars((wxString const &)*arg2);
18242
18243 wxPyEndAllowThreads(__tstate);
18244 if (PyErr_Occurred()) SWIG_fail;
18245 }
18246 {
18247 #if wxUSE_UNICODE
18248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18249 #else
18250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18251 #endif
18252 }
18253 {
18254 if (temp2)
18255 delete arg2;
18256 }
18257 return resultobj;
18258 fail:
18259 {
18260 if (temp2)
18261 delete arg2;
18262 }
18263 return NULL;
18264 }
18265
18266
18267 static PyObject *_wrap_ConfigBase_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18268 PyObject *resultobj;
18269 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18270 wxString result;
18271 PyObject * obj0 = 0 ;
18272 char *kwnames[] = {
18273 (char *) "self", NULL
18274 };
18275
18276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetAppName",kwnames,&obj0)) goto fail;
18277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18278 if (SWIG_arg_fail(1)) SWIG_fail;
18279 {
18280 PyThreadState* __tstate = wxPyBeginAllowThreads();
18281 result = ((wxConfigBase const *)arg1)->GetAppName();
18282
18283 wxPyEndAllowThreads(__tstate);
18284 if (PyErr_Occurred()) SWIG_fail;
18285 }
18286 {
18287 #if wxUSE_UNICODE
18288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18289 #else
18290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18291 #endif
18292 }
18293 return resultobj;
18294 fail:
18295 return NULL;
18296 }
18297
18298
18299 static PyObject *_wrap_ConfigBase_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18300 PyObject *resultobj;
18301 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18302 wxString result;
18303 PyObject * obj0 = 0 ;
18304 char *kwnames[] = {
18305 (char *) "self", NULL
18306 };
18307
18308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetVendorName",kwnames,&obj0)) goto fail;
18309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18310 if (SWIG_arg_fail(1)) SWIG_fail;
18311 {
18312 PyThreadState* __tstate = wxPyBeginAllowThreads();
18313 result = ((wxConfigBase const *)arg1)->GetVendorName();
18314
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 {
18319 #if wxUSE_UNICODE
18320 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18321 #else
18322 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18323 #endif
18324 }
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_ConfigBase_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj;
18333 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18334 wxString *arg2 = 0 ;
18335 bool temp2 = false ;
18336 PyObject * obj0 = 0 ;
18337 PyObject * obj1 = 0 ;
18338 char *kwnames[] = {
18339 (char *) "self",(char *) "appName", NULL
18340 };
18341
18342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetAppName",kwnames,&obj0,&obj1)) goto fail;
18343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18344 if (SWIG_arg_fail(1)) SWIG_fail;
18345 {
18346 arg2 = wxString_in_helper(obj1);
18347 if (arg2 == NULL) SWIG_fail;
18348 temp2 = true;
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 (arg1)->SetAppName((wxString const &)*arg2);
18353
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 Py_INCREF(Py_None); resultobj = Py_None;
18358 {
18359 if (temp2)
18360 delete arg2;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (temp2)
18366 delete arg2;
18367 }
18368 return NULL;
18369 }
18370
18371
18372 static PyObject *_wrap_ConfigBase_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj;
18374 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18375 wxString *arg2 = 0 ;
18376 bool temp2 = false ;
18377 PyObject * obj0 = 0 ;
18378 PyObject * obj1 = 0 ;
18379 char *kwnames[] = {
18380 (char *) "self",(char *) "vendorName", NULL
18381 };
18382
18383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
18384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18385 if (SWIG_arg_fail(1)) SWIG_fail;
18386 {
18387 arg2 = wxString_in_helper(obj1);
18388 if (arg2 == NULL) SWIG_fail;
18389 temp2 = true;
18390 }
18391 {
18392 PyThreadState* __tstate = wxPyBeginAllowThreads();
18393 (arg1)->SetVendorName((wxString const &)*arg2);
18394
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 Py_INCREF(Py_None); resultobj = Py_None;
18399 {
18400 if (temp2)
18401 delete arg2;
18402 }
18403 return resultobj;
18404 fail:
18405 {
18406 if (temp2)
18407 delete arg2;
18408 }
18409 return NULL;
18410 }
18411
18412
18413 static PyObject *_wrap_ConfigBase_SetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18414 PyObject *resultobj;
18415 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18416 long arg2 ;
18417 PyObject * obj0 = 0 ;
18418 PyObject * obj1 = 0 ;
18419 char *kwnames[] = {
18420 (char *) "self",(char *) "style", NULL
18421 };
18422
18423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ConfigBase_SetStyle",kwnames,&obj0,&obj1)) goto fail;
18424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18425 if (SWIG_arg_fail(1)) SWIG_fail;
18426 {
18427 arg2 = (long)(SWIG_As_long(obj1));
18428 if (SWIG_arg_fail(2)) SWIG_fail;
18429 }
18430 {
18431 PyThreadState* __tstate = wxPyBeginAllowThreads();
18432 (arg1)->SetStyle(arg2);
18433
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 Py_INCREF(Py_None); resultobj = Py_None;
18438 return resultobj;
18439 fail:
18440 return NULL;
18441 }
18442
18443
18444 static PyObject *_wrap_ConfigBase_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
18445 PyObject *resultobj;
18446 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18447 long result;
18448 PyObject * obj0 = 0 ;
18449 char *kwnames[] = {
18450 (char *) "self", NULL
18451 };
18452
18453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigBase_GetStyle",kwnames,&obj0)) goto fail;
18454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18455 if (SWIG_arg_fail(1)) SWIG_fail;
18456 {
18457 PyThreadState* __tstate = wxPyBeginAllowThreads();
18458 result = (long)((wxConfigBase const *)arg1)->GetStyle();
18459
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 {
18464 resultobj = SWIG_From_long((long)(result));
18465 }
18466 return resultobj;
18467 fail:
18468 return NULL;
18469 }
18470
18471
18472 static PyObject * ConfigBase_swigregister(PyObject *, PyObject *args) {
18473 PyObject *obj;
18474 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18475 SWIG_TypeClientData(SWIGTYPE_p_wxConfigBase, obj);
18476 Py_INCREF(obj);
18477 return Py_BuildValue((char *)"");
18478 }
18479 static PyObject *_wrap_new_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18480 PyObject *resultobj;
18481 wxString const &arg1_defvalue = wxPyEmptyString ;
18482 wxString *arg1 = (wxString *) &arg1_defvalue ;
18483 wxString const &arg2_defvalue = wxPyEmptyString ;
18484 wxString *arg2 = (wxString *) &arg2_defvalue ;
18485 wxString const &arg3_defvalue = wxPyEmptyString ;
18486 wxString *arg3 = (wxString *) &arg3_defvalue ;
18487 wxString const &arg4_defvalue = wxPyEmptyString ;
18488 wxString *arg4 = (wxString *) &arg4_defvalue ;
18489 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18490 wxConfig *result;
18491 bool temp1 = false ;
18492 bool temp2 = false ;
18493 bool temp3 = false ;
18494 bool temp4 = false ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 PyObject * obj2 = 0 ;
18498 PyObject * obj3 = 0 ;
18499 PyObject * obj4 = 0 ;
18500 char *kwnames[] = {
18501 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18502 };
18503
18504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_Config",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18505 if (obj0) {
18506 {
18507 arg1 = wxString_in_helper(obj0);
18508 if (arg1 == NULL) SWIG_fail;
18509 temp1 = true;
18510 }
18511 }
18512 if (obj1) {
18513 {
18514 arg2 = wxString_in_helper(obj1);
18515 if (arg2 == NULL) SWIG_fail;
18516 temp2 = true;
18517 }
18518 }
18519 if (obj2) {
18520 {
18521 arg3 = wxString_in_helper(obj2);
18522 if (arg3 == NULL) SWIG_fail;
18523 temp3 = true;
18524 }
18525 }
18526 if (obj3) {
18527 {
18528 arg4 = wxString_in_helper(obj3);
18529 if (arg4 == NULL) SWIG_fail;
18530 temp4 = true;
18531 }
18532 }
18533 if (obj4) {
18534 {
18535 arg5 = (long)(SWIG_As_long(obj4));
18536 if (SWIG_arg_fail(5)) SWIG_fail;
18537 }
18538 }
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 result = (wxConfig *)new wxConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18542
18543 wxPyEndAllowThreads(__tstate);
18544 if (PyErr_Occurred()) SWIG_fail;
18545 }
18546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfig, 1);
18547 {
18548 if (temp1)
18549 delete arg1;
18550 }
18551 {
18552 if (temp2)
18553 delete arg2;
18554 }
18555 {
18556 if (temp3)
18557 delete arg3;
18558 }
18559 {
18560 if (temp4)
18561 delete arg4;
18562 }
18563 return resultobj;
18564 fail:
18565 {
18566 if (temp1)
18567 delete arg1;
18568 }
18569 {
18570 if (temp2)
18571 delete arg2;
18572 }
18573 {
18574 if (temp3)
18575 delete arg3;
18576 }
18577 {
18578 if (temp4)
18579 delete arg4;
18580 }
18581 return NULL;
18582 }
18583
18584
18585 static PyObject *_wrap_delete_Config(PyObject *, PyObject *args, PyObject *kwargs) {
18586 PyObject *resultobj;
18587 wxConfig *arg1 = (wxConfig *) 0 ;
18588 PyObject * obj0 = 0 ;
18589 char *kwnames[] = {
18590 (char *) "self", NULL
18591 };
18592
18593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Config",kwnames,&obj0)) goto fail;
18594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfig, SWIG_POINTER_EXCEPTION | 0);
18595 if (SWIG_arg_fail(1)) SWIG_fail;
18596 {
18597 PyThreadState* __tstate = wxPyBeginAllowThreads();
18598 delete arg1;
18599
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 Py_INCREF(Py_None); resultobj = Py_None;
18604 return resultobj;
18605 fail:
18606 return NULL;
18607 }
18608
18609
18610 static PyObject * Config_swigregister(PyObject *, PyObject *args) {
18611 PyObject *obj;
18612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18613 SWIG_TypeClientData(SWIGTYPE_p_wxConfig, obj);
18614 Py_INCREF(obj);
18615 return Py_BuildValue((char *)"");
18616 }
18617 static PyObject *_wrap_new_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18618 PyObject *resultobj;
18619 wxString const &arg1_defvalue = wxPyEmptyString ;
18620 wxString *arg1 = (wxString *) &arg1_defvalue ;
18621 wxString const &arg2_defvalue = wxPyEmptyString ;
18622 wxString *arg2 = (wxString *) &arg2_defvalue ;
18623 wxString const &arg3_defvalue = wxPyEmptyString ;
18624 wxString *arg3 = (wxString *) &arg3_defvalue ;
18625 wxString const &arg4_defvalue = wxPyEmptyString ;
18626 wxString *arg4 = (wxString *) &arg4_defvalue ;
18627 long arg5 = (long) wxCONFIG_USE_LOCAL_FILE|wxCONFIG_USE_GLOBAL_FILE ;
18628 wxFileConfig *result;
18629 bool temp1 = false ;
18630 bool temp2 = false ;
18631 bool temp3 = false ;
18632 bool temp4 = false ;
18633 PyObject * obj0 = 0 ;
18634 PyObject * obj1 = 0 ;
18635 PyObject * obj2 = 0 ;
18636 PyObject * obj3 = 0 ;
18637 PyObject * obj4 = 0 ;
18638 char *kwnames[] = {
18639 (char *) "appName",(char *) "vendorName",(char *) "localFilename",(char *) "globalFilename",(char *) "style", NULL
18640 };
18641
18642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOO:new_FileConfig",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
18643 if (obj0) {
18644 {
18645 arg1 = wxString_in_helper(obj0);
18646 if (arg1 == NULL) SWIG_fail;
18647 temp1 = true;
18648 }
18649 }
18650 if (obj1) {
18651 {
18652 arg2 = wxString_in_helper(obj1);
18653 if (arg2 == NULL) SWIG_fail;
18654 temp2 = true;
18655 }
18656 }
18657 if (obj2) {
18658 {
18659 arg3 = wxString_in_helper(obj2);
18660 if (arg3 == NULL) SWIG_fail;
18661 temp3 = true;
18662 }
18663 }
18664 if (obj3) {
18665 {
18666 arg4 = wxString_in_helper(obj3);
18667 if (arg4 == NULL) SWIG_fail;
18668 temp4 = true;
18669 }
18670 }
18671 if (obj4) {
18672 {
18673 arg5 = (long)(SWIG_As_long(obj4));
18674 if (SWIG_arg_fail(5)) SWIG_fail;
18675 }
18676 }
18677 {
18678 PyThreadState* __tstate = wxPyBeginAllowThreads();
18679 result = (wxFileConfig *)new wxFileConfig((wxString const &)*arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
18680
18681 wxPyEndAllowThreads(__tstate);
18682 if (PyErr_Occurred()) SWIG_fail;
18683 }
18684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileConfig, 1);
18685 {
18686 if (temp1)
18687 delete arg1;
18688 }
18689 {
18690 if (temp2)
18691 delete arg2;
18692 }
18693 {
18694 if (temp3)
18695 delete arg3;
18696 }
18697 {
18698 if (temp4)
18699 delete arg4;
18700 }
18701 return resultobj;
18702 fail:
18703 {
18704 if (temp1)
18705 delete arg1;
18706 }
18707 {
18708 if (temp2)
18709 delete arg2;
18710 }
18711 {
18712 if (temp3)
18713 delete arg3;
18714 }
18715 {
18716 if (temp4)
18717 delete arg4;
18718 }
18719 return NULL;
18720 }
18721
18722
18723 static PyObject *_wrap_delete_FileConfig(PyObject *, PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj;
18725 wxFileConfig *arg1 = (wxFileConfig *) 0 ;
18726 PyObject * obj0 = 0 ;
18727 char *kwnames[] = {
18728 (char *) "self", NULL
18729 };
18730
18731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileConfig",kwnames,&obj0)) goto fail;
18732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileConfig, SWIG_POINTER_EXCEPTION | 0);
18733 if (SWIG_arg_fail(1)) SWIG_fail;
18734 {
18735 PyThreadState* __tstate = wxPyBeginAllowThreads();
18736 delete arg1;
18737
18738 wxPyEndAllowThreads(__tstate);
18739 if (PyErr_Occurred()) SWIG_fail;
18740 }
18741 Py_INCREF(Py_None); resultobj = Py_None;
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 static PyObject * FileConfig_swigregister(PyObject *, PyObject *args) {
18749 PyObject *obj;
18750 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18751 SWIG_TypeClientData(SWIGTYPE_p_wxFileConfig, obj);
18752 Py_INCREF(obj);
18753 return Py_BuildValue((char *)"");
18754 }
18755 static PyObject *_wrap_new_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj;
18757 wxConfigBase *arg1 = (wxConfigBase *) 0 ;
18758 wxString *arg2 = 0 ;
18759 wxConfigPathChanger *result;
18760 bool temp2 = false ;
18761 PyObject * obj0 = 0 ;
18762 PyObject * obj1 = 0 ;
18763 char *kwnames[] = {
18764 (char *) "config",(char *) "entry", NULL
18765 };
18766
18767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_ConfigPathChanger",kwnames,&obj0,&obj1)) goto fail;
18768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigBase, SWIG_POINTER_EXCEPTION | 0);
18769 if (SWIG_arg_fail(1)) SWIG_fail;
18770 {
18771 arg2 = wxString_in_helper(obj1);
18772 if (arg2 == NULL) SWIG_fail;
18773 temp2 = true;
18774 }
18775 {
18776 PyThreadState* __tstate = wxPyBeginAllowThreads();
18777 result = (wxConfigPathChanger *)new wxConfigPathChanger((wxConfigBase const *)arg1,(wxString const &)*arg2);
18778
18779 wxPyEndAllowThreads(__tstate);
18780 if (PyErr_Occurred()) SWIG_fail;
18781 }
18782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxConfigPathChanger, 1);
18783 {
18784 if (temp2)
18785 delete arg2;
18786 }
18787 return resultobj;
18788 fail:
18789 {
18790 if (temp2)
18791 delete arg2;
18792 }
18793 return NULL;
18794 }
18795
18796
18797 static PyObject *_wrap_delete_ConfigPathChanger(PyObject *, PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj;
18799 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18800 PyObject * obj0 = 0 ;
18801 char *kwnames[] = {
18802 (char *) "self", NULL
18803 };
18804
18805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ConfigPathChanger",kwnames,&obj0)) goto fail;
18806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18807 if (SWIG_arg_fail(1)) SWIG_fail;
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 delete arg1;
18811
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 Py_INCREF(Py_None); resultobj = Py_None;
18816 return resultobj;
18817 fail:
18818 return NULL;
18819 }
18820
18821
18822 static PyObject *_wrap_ConfigPathChanger_Name(PyObject *, PyObject *args, PyObject *kwargs) {
18823 PyObject *resultobj;
18824 wxConfigPathChanger *arg1 = (wxConfigPathChanger *) 0 ;
18825 wxString *result;
18826 PyObject * obj0 = 0 ;
18827 char *kwnames[] = {
18828 (char *) "self", NULL
18829 };
18830
18831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ConfigPathChanger_Name",kwnames,&obj0)) goto fail;
18832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxConfigPathChanger, SWIG_POINTER_EXCEPTION | 0);
18833 if (SWIG_arg_fail(1)) SWIG_fail;
18834 {
18835 PyThreadState* __tstate = wxPyBeginAllowThreads();
18836 {
18837 wxString const &_result_ref = ((wxConfigPathChanger const *)arg1)->Name();
18838 result = (wxString *) &_result_ref;
18839 }
18840
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 {
18845 #if wxUSE_UNICODE
18846 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
18847 #else
18848 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
18849 #endif
18850 }
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 static PyObject * ConfigPathChanger_swigregister(PyObject *, PyObject *args) {
18858 PyObject *obj;
18859 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18860 SWIG_TypeClientData(SWIGTYPE_p_wxConfigPathChanger, obj);
18861 Py_INCREF(obj);
18862 return Py_BuildValue((char *)"");
18863 }
18864 static PyObject *_wrap_ExpandEnvVars(PyObject *, PyObject *args, PyObject *kwargs) {
18865 PyObject *resultobj;
18866 wxString *arg1 = 0 ;
18867 wxString result;
18868 bool temp1 = false ;
18869 PyObject * obj0 = 0 ;
18870 char *kwnames[] = {
18871 (char *) "sz", NULL
18872 };
18873
18874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ExpandEnvVars",kwnames,&obj0)) goto fail;
18875 {
18876 arg1 = wxString_in_helper(obj0);
18877 if (arg1 == NULL) SWIG_fail;
18878 temp1 = true;
18879 }
18880 {
18881 PyThreadState* __tstate = wxPyBeginAllowThreads();
18882 result = wxExpandEnvVars((wxString const &)*arg1);
18883
18884 wxPyEndAllowThreads(__tstate);
18885 if (PyErr_Occurred()) SWIG_fail;
18886 }
18887 {
18888 #if wxUSE_UNICODE
18889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18890 #else
18891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18892 #endif
18893 }
18894 {
18895 if (temp1)
18896 delete arg1;
18897 }
18898 return resultobj;
18899 fail:
18900 {
18901 if (temp1)
18902 delete arg1;
18903 }
18904 return NULL;
18905 }
18906
18907
18908 static int _wrap_DefaultDateTimeFormat_set(PyObject *) {
18909 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTimeFormat is read-only.");
18910 return 1;
18911 }
18912
18913
18914 static PyObject *_wrap_DefaultDateTimeFormat_get(void) {
18915 PyObject *pyobj;
18916
18917 {
18918 #if wxUSE_UNICODE
18919 pyobj = PyUnicode_FromWideChar((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18920 #else
18921 pyobj = PyString_FromStringAndSize((&wxPyDefaultDateTimeFormat)->c_str(), (&wxPyDefaultDateTimeFormat)->Len());
18922 #endif
18923 }
18924 return pyobj;
18925 }
18926
18927
18928 static int _wrap_DefaultTimeSpanFormat_set(PyObject *) {
18929 PyErr_SetString(PyExc_TypeError,"Variable DefaultTimeSpanFormat is read-only.");
18930 return 1;
18931 }
18932
18933
18934 static PyObject *_wrap_DefaultTimeSpanFormat_get(void) {
18935 PyObject *pyobj;
18936
18937 {
18938 #if wxUSE_UNICODE
18939 pyobj = PyUnicode_FromWideChar((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18940 #else
18941 pyobj = PyString_FromStringAndSize((&wxPyDefaultTimeSpanFormat)->c_str(), (&wxPyDefaultTimeSpanFormat)->Len());
18942 #endif
18943 }
18944 return pyobj;
18945 }
18946
18947
18948 static PyObject *_wrap_DateTime_SetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18949 PyObject *resultobj;
18950 wxDateTime::Country arg1 ;
18951 PyObject * obj0 = 0 ;
18952 char *kwnames[] = {
18953 (char *) "country", NULL
18954 };
18955
18956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetCountry",kwnames,&obj0)) goto fail;
18957 {
18958 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
18959 if (SWIG_arg_fail(1)) SWIG_fail;
18960 }
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 wxDateTime::SetCountry((wxDateTime::Country )arg1);
18964
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 Py_INCREF(Py_None); resultobj = Py_None;
18969 return resultobj;
18970 fail:
18971 return NULL;
18972 }
18973
18974
18975 static PyObject *_wrap_DateTime_GetCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18976 PyObject *resultobj;
18977 wxDateTime::Country result;
18978 char *kwnames[] = {
18979 NULL
18980 };
18981
18982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetCountry",kwnames)) goto fail;
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 result = (wxDateTime::Country)wxDateTime::GetCountry();
18986
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 resultobj = SWIG_From_int((result));
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 static PyObject *_wrap_DateTime_IsWestEuropeanCountry(PyObject *, PyObject *args, PyObject *kwargs) {
18998 PyObject *resultobj;
18999 wxDateTime::Country arg1 = (wxDateTime::Country) wxDateTime::Country_Default ;
19000 bool result;
19001 PyObject * obj0 = 0 ;
19002 char *kwnames[] = {
19003 (char *) "country", NULL
19004 };
19005
19006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_IsWestEuropeanCountry",kwnames,&obj0)) goto fail;
19007 if (obj0) {
19008 {
19009 arg1 = (wxDateTime::Country)(SWIG_As_int(obj0));
19010 if (SWIG_arg_fail(1)) SWIG_fail;
19011 }
19012 }
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = (bool)wxDateTime::IsWestEuropeanCountry((wxDateTime::Country )arg1);
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 {
19021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19022 }
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 static PyObject *_wrap_DateTime_GetCurrentYear(PyObject *, PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj;
19031 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19032 int result;
19033 PyObject * obj0 = 0 ;
19034 char *kwnames[] = {
19035 (char *) "cal", NULL
19036 };
19037
19038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentYear",kwnames,&obj0)) goto fail;
19039 if (obj0) {
19040 {
19041 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19042 if (SWIG_arg_fail(1)) SWIG_fail;
19043 }
19044 }
19045 {
19046 PyThreadState* __tstate = wxPyBeginAllowThreads();
19047 result = (int)wxDateTime::GetCurrentYear((wxDateTime::Calendar )arg1);
19048
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 {
19053 resultobj = SWIG_From_int((int)(result));
19054 }
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 static PyObject *_wrap_DateTime_ConvertYearToBC(PyObject *, PyObject *args, PyObject *kwargs) {
19062 PyObject *resultobj;
19063 int arg1 ;
19064 int result;
19065 PyObject * obj0 = 0 ;
19066 char *kwnames[] = {
19067 (char *) "year", NULL
19068 };
19069
19070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ConvertYearToBC",kwnames,&obj0)) goto fail;
19071 {
19072 arg1 = (int)(SWIG_As_int(obj0));
19073 if (SWIG_arg_fail(1)) SWIG_fail;
19074 }
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 result = (int)wxDateTime::ConvertYearToBC(arg1);
19078
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 {
19083 resultobj = SWIG_From_int((int)(result));
19084 }
19085 return resultobj;
19086 fail:
19087 return NULL;
19088 }
19089
19090
19091 static PyObject *_wrap_DateTime_GetCurrentMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj;
19093 wxDateTime::Calendar arg1 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19094 wxDateTime::Month result;
19095 PyObject * obj0 = 0 ;
19096 char *kwnames[] = {
19097 (char *) "cal", NULL
19098 };
19099
19100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCurrentMonth",kwnames,&obj0)) goto fail;
19101 if (obj0) {
19102 {
19103 arg1 = (wxDateTime::Calendar)(SWIG_As_int(obj0));
19104 if (SWIG_arg_fail(1)) SWIG_fail;
19105 }
19106 }
19107 {
19108 PyThreadState* __tstate = wxPyBeginAllowThreads();
19109 result = (wxDateTime::Month)wxDateTime::GetCurrentMonth((wxDateTime::Calendar )arg1);
19110
19111 wxPyEndAllowThreads(__tstate);
19112 if (PyErr_Occurred()) SWIG_fail;
19113 }
19114 resultobj = SWIG_From_int((result));
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 static PyObject *_wrap_DateTime_IsLeapYear(PyObject *, PyObject *args, PyObject *kwargs) {
19122 PyObject *resultobj;
19123 int arg1 = (int) wxDateTime::Inv_Year ;
19124 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19125 bool result;
19126 PyObject * obj0 = 0 ;
19127 PyObject * obj1 = 0 ;
19128 char *kwnames[] = {
19129 (char *) "year",(char *) "cal", NULL
19130 };
19131
19132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsLeapYear",kwnames,&obj0,&obj1)) goto fail;
19133 if (obj0) {
19134 {
19135 arg1 = (int)(SWIG_As_int(obj0));
19136 if (SWIG_arg_fail(1)) SWIG_fail;
19137 }
19138 }
19139 if (obj1) {
19140 {
19141 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19142 if (SWIG_arg_fail(2)) SWIG_fail;
19143 }
19144 }
19145 {
19146 PyThreadState* __tstate = wxPyBeginAllowThreads();
19147 result = (bool)wxDateTime::IsLeapYear(arg1,(wxDateTime::Calendar )arg2);
19148
19149 wxPyEndAllowThreads(__tstate);
19150 if (PyErr_Occurred()) SWIG_fail;
19151 }
19152 {
19153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19154 }
19155 return resultobj;
19156 fail:
19157 return NULL;
19158 }
19159
19160
19161 static PyObject *_wrap_DateTime_GetCentury(PyObject *, PyObject *args, PyObject *kwargs) {
19162 PyObject *resultobj;
19163 int arg1 = (int) wxDateTime::Inv_Year ;
19164 int result;
19165 PyObject * obj0 = 0 ;
19166 char *kwnames[] = {
19167 (char *) "year", NULL
19168 };
19169
19170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:DateTime_GetCentury",kwnames,&obj0)) goto fail;
19171 if (obj0) {
19172 {
19173 arg1 = (int)(SWIG_As_int(obj0));
19174 if (SWIG_arg_fail(1)) SWIG_fail;
19175 }
19176 }
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (int)wxDateTime::GetCentury(arg1);
19180
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 {
19185 resultobj = SWIG_From_int((int)(result));
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 static PyObject *_wrap_DateTime_GetNumberOfDaysinYear(PyObject *, PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj;
19195 int arg1 ;
19196 wxDateTime::Calendar arg2 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19197 int result;
19198 PyObject * obj0 = 0 ;
19199 PyObject * obj1 = 0 ;
19200 char *kwnames[] = {
19201 (char *) "year",(char *) "cal", NULL
19202 };
19203
19204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetNumberOfDaysinYear",kwnames,&obj0,&obj1)) goto fail;
19205 {
19206 arg1 = (int)(SWIG_As_int(obj0));
19207 if (SWIG_arg_fail(1)) SWIG_fail;
19208 }
19209 if (obj1) {
19210 {
19211 arg2 = (wxDateTime::Calendar)(SWIG_As_int(obj1));
19212 if (SWIG_arg_fail(2)) SWIG_fail;
19213 }
19214 }
19215 {
19216 PyThreadState* __tstate = wxPyBeginAllowThreads();
19217 result = (int)wxDateTime::GetNumberOfDays(arg1,(wxDateTime::Calendar )arg2);
19218
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 {
19223 resultobj = SWIG_From_int((int)(result));
19224 }
19225 return resultobj;
19226 fail:
19227 return NULL;
19228 }
19229
19230
19231 static PyObject *_wrap_DateTime_GetNumberOfDaysInMonth(PyObject *, PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj;
19233 wxDateTime::Month arg1 ;
19234 int arg2 = (int) wxDateTime::Inv_Year ;
19235 wxDateTime::Calendar arg3 = (wxDateTime::Calendar) wxDateTime::Gregorian ;
19236 int result;
19237 PyObject * obj0 = 0 ;
19238 PyObject * obj1 = 0 ;
19239 PyObject * obj2 = 0 ;
19240 char *kwnames[] = {
19241 (char *) "month",(char *) "year",(char *) "cal", NULL
19242 };
19243
19244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetNumberOfDaysInMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
19245 {
19246 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 }
19249 if (obj1) {
19250 {
19251 arg2 = (int)(SWIG_As_int(obj1));
19252 if (SWIG_arg_fail(2)) SWIG_fail;
19253 }
19254 }
19255 if (obj2) {
19256 {
19257 arg3 = (wxDateTime::Calendar)(SWIG_As_int(obj2));
19258 if (SWIG_arg_fail(3)) SWIG_fail;
19259 }
19260 }
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (int)wxDateTime::GetNumberOfDays((wxDateTime::Month )arg1,arg2,(wxDateTime::Calendar )arg3);
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = SWIG_From_int((int)(result));
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_DateTime_GetMonthName(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj;
19279 wxDateTime::Month arg1 ;
19280 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19281 wxString result;
19282 PyObject * obj0 = 0 ;
19283 PyObject * obj1 = 0 ;
19284 char *kwnames[] = {
19285 (char *) "month",(char *) "flags", NULL
19286 };
19287
19288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonthName",kwnames,&obj0,&obj1)) goto fail;
19289 {
19290 arg1 = (wxDateTime::Month)(SWIG_As_int(obj0));
19291 if (SWIG_arg_fail(1)) SWIG_fail;
19292 }
19293 if (obj1) {
19294 {
19295 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19296 if (SWIG_arg_fail(2)) SWIG_fail;
19297 }
19298 }
19299 {
19300 PyThreadState* __tstate = wxPyBeginAllowThreads();
19301 result = wxDateTime::GetMonthName((wxDateTime::Month )arg1,(wxDateTime::NameFlags )arg2);
19302
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 {
19307 #if wxUSE_UNICODE
19308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19309 #else
19310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19311 #endif
19312 }
19313 return resultobj;
19314 fail:
19315 return NULL;
19316 }
19317
19318
19319 static PyObject *_wrap_DateTime_GetWeekDayName(PyObject *, PyObject *args, PyObject *kwargs) {
19320 PyObject *resultobj;
19321 wxDateTime::WeekDay arg1 ;
19322 wxDateTime::NameFlags arg2 = (wxDateTime::NameFlags) wxDateTime::Name_Full ;
19323 wxString result;
19324 PyObject * obj0 = 0 ;
19325 PyObject * obj1 = 0 ;
19326 char *kwnames[] = {
19327 (char *) "weekday",(char *) "flags", NULL
19328 };
19329
19330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDayName",kwnames,&obj0,&obj1)) goto fail;
19331 {
19332 arg1 = (wxDateTime::WeekDay)(SWIG_As_int(obj0));
19333 if (SWIG_arg_fail(1)) SWIG_fail;
19334 }
19335 if (obj1) {
19336 {
19337 arg2 = (wxDateTime::NameFlags)(SWIG_As_int(obj1));
19338 if (SWIG_arg_fail(2)) SWIG_fail;
19339 }
19340 }
19341 {
19342 PyThreadState* __tstate = wxPyBeginAllowThreads();
19343 result = wxDateTime::GetWeekDayName((wxDateTime::WeekDay )arg1,(wxDateTime::NameFlags )arg2);
19344
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 {
19349 #if wxUSE_UNICODE
19350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19351 #else
19352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19353 #endif
19354 }
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_DateTime_GetAmPmStrings(PyObject *, PyObject *args, PyObject *kwargs) {
19362 PyObject *resultobj;
19363 PyObject *result;
19364 char *kwnames[] = {
19365 NULL
19366 };
19367
19368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_GetAmPmStrings",kwnames)) goto fail;
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 result = (PyObject *)DateTime_GetAmPmStrings();
19372
19373 wxPyEndAllowThreads(__tstate);
19374 if (PyErr_Occurred()) SWIG_fail;
19375 }
19376 resultobj = result;
19377 return resultobj;
19378 fail:
19379 return NULL;
19380 }
19381
19382
19383 static PyObject *_wrap_DateTime_IsDSTApplicable(PyObject *, PyObject *args, PyObject *kwargs) {
19384 PyObject *resultobj;
19385 int arg1 = (int) wxDateTime::Inv_Year ;
19386 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19387 bool result;
19388 PyObject * obj0 = 0 ;
19389 PyObject * obj1 = 0 ;
19390 char *kwnames[] = {
19391 (char *) "year",(char *) "country", NULL
19392 };
19393
19394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_IsDSTApplicable",kwnames,&obj0,&obj1)) goto fail;
19395 if (obj0) {
19396 {
19397 arg1 = (int)(SWIG_As_int(obj0));
19398 if (SWIG_arg_fail(1)) SWIG_fail;
19399 }
19400 }
19401 if (obj1) {
19402 {
19403 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19404 if (SWIG_arg_fail(2)) SWIG_fail;
19405 }
19406 }
19407 {
19408 PyThreadState* __tstate = wxPyBeginAllowThreads();
19409 result = (bool)wxDateTime::IsDSTApplicable(arg1,(wxDateTime::Country )arg2);
19410
19411 wxPyEndAllowThreads(__tstate);
19412 if (PyErr_Occurred()) SWIG_fail;
19413 }
19414 {
19415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19416 }
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_DateTime_GetBeginDST(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj;
19425 int arg1 = (int) wxDateTime::Inv_Year ;
19426 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19427 wxDateTime result;
19428 PyObject * obj0 = 0 ;
19429 PyObject * obj1 = 0 ;
19430 char *kwnames[] = {
19431 (char *) "year",(char *) "country", NULL
19432 };
19433
19434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetBeginDST",kwnames,&obj0,&obj1)) goto fail;
19435 if (obj0) {
19436 {
19437 arg1 = (int)(SWIG_As_int(obj0));
19438 if (SWIG_arg_fail(1)) SWIG_fail;
19439 }
19440 }
19441 if (obj1) {
19442 {
19443 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19444 if (SWIG_arg_fail(2)) SWIG_fail;
19445 }
19446 }
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = wxDateTime::GetBeginDST(arg1,(wxDateTime::Country )arg2);
19450
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 {
19455 wxDateTime * resultptr;
19456 resultptr = new wxDateTime((wxDateTime &)(result));
19457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19458 }
19459 return resultobj;
19460 fail:
19461 return NULL;
19462 }
19463
19464
19465 static PyObject *_wrap_DateTime_GetEndDST(PyObject *, PyObject *args, PyObject *kwargs) {
19466 PyObject *resultobj;
19467 int arg1 = (int) wxDateTime::Inv_Year ;
19468 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
19469 wxDateTime result;
19470 PyObject * obj0 = 0 ;
19471 PyObject * obj1 = 0 ;
19472 char *kwnames[] = {
19473 (char *) "year",(char *) "country", NULL
19474 };
19475
19476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:DateTime_GetEndDST",kwnames,&obj0,&obj1)) goto fail;
19477 if (obj0) {
19478 {
19479 arg1 = (int)(SWIG_As_int(obj0));
19480 if (SWIG_arg_fail(1)) SWIG_fail;
19481 }
19482 }
19483 if (obj1) {
19484 {
19485 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
19486 if (SWIG_arg_fail(2)) SWIG_fail;
19487 }
19488 }
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = wxDateTime::GetEndDST(arg1,(wxDateTime::Country )arg2);
19492
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 {
19497 wxDateTime * resultptr;
19498 resultptr = new wxDateTime((wxDateTime &)(result));
19499 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19500 }
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_DateTime_Now(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 wxDateTime result;
19510 char *kwnames[] = {
19511 NULL
19512 };
19513
19514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Now",kwnames)) goto fail;
19515 {
19516 PyThreadState* __tstate = wxPyBeginAllowThreads();
19517 result = wxDateTime::Now();
19518
19519 wxPyEndAllowThreads(__tstate);
19520 if (PyErr_Occurred()) SWIG_fail;
19521 }
19522 {
19523 wxDateTime * resultptr;
19524 resultptr = new wxDateTime((wxDateTime &)(result));
19525 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19526 }
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 static PyObject *_wrap_DateTime_UNow(PyObject *, PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj;
19535 wxDateTime result;
19536 char *kwnames[] = {
19537 NULL
19538 };
19539
19540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_UNow",kwnames)) goto fail;
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 result = wxDateTime::UNow();
19544
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 {
19549 wxDateTime * resultptr;
19550 resultptr = new wxDateTime((wxDateTime &)(result));
19551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19552 }
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 static PyObject *_wrap_DateTime_Today(PyObject *, PyObject *args, PyObject *kwargs) {
19560 PyObject *resultobj;
19561 wxDateTime result;
19562 char *kwnames[] = {
19563 NULL
19564 };
19565
19566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateTime_Today",kwnames)) goto fail;
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 result = wxDateTime::Today();
19570
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 {
19575 wxDateTime * resultptr;
19576 resultptr = new wxDateTime((wxDateTime &)(result));
19577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
19578 }
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_new_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 wxDateTime *result;
19588 char *kwnames[] = {
19589 NULL
19590 };
19591
19592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DateTime",kwnames)) goto fail;
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 result = (wxDateTime *)new wxDateTime();
19596
19597 wxPyEndAllowThreads(__tstate);
19598 if (PyErr_Occurred()) SWIG_fail;
19599 }
19600 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 static PyObject *_wrap_new_DateTimeFromTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj;
19609 time_t arg1 ;
19610 wxDateTime *result;
19611 PyObject * obj0 = 0 ;
19612 char *kwnames[] = {
19613 (char *) "timet", NULL
19614 };
19615
19616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromTimeT",kwnames,&obj0)) goto fail;
19617 {
19618 arg1 = (time_t)(SWIG_As_unsigned_SS_int(obj0));
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 }
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 result = (wxDateTime *)new wxDateTime(arg1);
19624
19625 wxPyEndAllowThreads(__tstate);
19626 if (PyErr_Occurred()) SWIG_fail;
19627 }
19628 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19629 return resultobj;
19630 fail:
19631 return NULL;
19632 }
19633
19634
19635 static PyObject *_wrap_new_DateTimeFromJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19636 PyObject *resultobj;
19637 double arg1 ;
19638 wxDateTime *result;
19639 PyObject * obj0 = 0 ;
19640 char *kwnames[] = {
19641 (char *) "jdn", NULL
19642 };
19643
19644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DateTimeFromJDN",kwnames,&obj0)) goto fail;
19645 {
19646 arg1 = (double)(SWIG_As_double(obj0));
19647 if (SWIG_arg_fail(1)) SWIG_fail;
19648 }
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 result = (wxDateTime *)new wxDateTime(arg1);
19652
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_new_DateTimeFromHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj;
19665 int arg1 ;
19666 int arg2 = (int) 0 ;
19667 int arg3 = (int) 0 ;
19668 int arg4 = (int) 0 ;
19669 wxDateTime *result;
19670 PyObject * obj0 = 0 ;
19671 PyObject * obj1 = 0 ;
19672 PyObject * obj2 = 0 ;
19673 PyObject * obj3 = 0 ;
19674 char *kwnames[] = {
19675 (char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19676 };
19677
19678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DateTimeFromHMS",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
19679 {
19680 arg1 = (int)(SWIG_As_int(obj0));
19681 if (SWIG_arg_fail(1)) SWIG_fail;
19682 }
19683 if (obj1) {
19684 {
19685 arg2 = (int)(SWIG_As_int(obj1));
19686 if (SWIG_arg_fail(2)) SWIG_fail;
19687 }
19688 }
19689 if (obj2) {
19690 {
19691 arg3 = (int)(SWIG_As_int(obj2));
19692 if (SWIG_arg_fail(3)) SWIG_fail;
19693 }
19694 }
19695 if (obj3) {
19696 {
19697 arg4 = (int)(SWIG_As_int(obj3));
19698 if (SWIG_arg_fail(4)) SWIG_fail;
19699 }
19700 }
19701 {
19702 PyThreadState* __tstate = wxPyBeginAllowThreads();
19703 result = (wxDateTime *)new wxDateTime(arg1,arg2,arg3,arg4);
19704
19705 wxPyEndAllowThreads(__tstate);
19706 if (PyErr_Occurred()) SWIG_fail;
19707 }
19708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19709 return resultobj;
19710 fail:
19711 return NULL;
19712 }
19713
19714
19715 static PyObject *_wrap_new_DateTimeFromDMY(PyObject *, PyObject *args, PyObject *kwargs) {
19716 PyObject *resultobj;
19717 int arg1 ;
19718 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19719 int arg3 = (int) wxDateTime::Inv_Year ;
19720 int arg4 = (int) 0 ;
19721 int arg5 = (int) 0 ;
19722 int arg6 = (int) 0 ;
19723 int arg7 = (int) 0 ;
19724 wxDateTime *result;
19725 PyObject * obj0 = 0 ;
19726 PyObject * obj1 = 0 ;
19727 PyObject * obj2 = 0 ;
19728 PyObject * obj3 = 0 ;
19729 PyObject * obj4 = 0 ;
19730 PyObject * obj5 = 0 ;
19731 PyObject * obj6 = 0 ;
19732 char *kwnames[] = {
19733 (char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19734 };
19735
19736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_DateTimeFromDMY",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
19737 {
19738 arg1 = (int)(SWIG_As_int(obj0));
19739 if (SWIG_arg_fail(1)) SWIG_fail;
19740 }
19741 if (obj1) {
19742 {
19743 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
19744 if (SWIG_arg_fail(2)) SWIG_fail;
19745 }
19746 }
19747 if (obj2) {
19748 {
19749 arg3 = (int)(SWIG_As_int(obj2));
19750 if (SWIG_arg_fail(3)) SWIG_fail;
19751 }
19752 }
19753 if (obj3) {
19754 {
19755 arg4 = (int)(SWIG_As_int(obj3));
19756 if (SWIG_arg_fail(4)) SWIG_fail;
19757 }
19758 }
19759 if (obj4) {
19760 {
19761 arg5 = (int)(SWIG_As_int(obj4));
19762 if (SWIG_arg_fail(5)) SWIG_fail;
19763 }
19764 }
19765 if (obj5) {
19766 {
19767 arg6 = (int)(SWIG_As_int(obj5));
19768 if (SWIG_arg_fail(6)) SWIG_fail;
19769 }
19770 }
19771 if (obj6) {
19772 {
19773 arg7 = (int)(SWIG_As_int(obj6));
19774 if (SWIG_arg_fail(7)) SWIG_fail;
19775 }
19776 }
19777 {
19778 PyThreadState* __tstate = wxPyBeginAllowThreads();
19779 result = (wxDateTime *)new wxDateTime(arg1,(wxDateTime::Month )arg2,arg3,arg4,arg5,arg6,arg7);
19780
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
19785 return resultobj;
19786 fail:
19787 return NULL;
19788 }
19789
19790
19791 static PyObject *_wrap_delete_DateTime(PyObject *, PyObject *args, PyObject *kwargs) {
19792 PyObject *resultobj;
19793 wxDateTime *arg1 = (wxDateTime *) 0 ;
19794 PyObject * obj0 = 0 ;
19795 char *kwnames[] = {
19796 (char *) "self", NULL
19797 };
19798
19799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateTime",kwnames,&obj0)) goto fail;
19800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19801 if (SWIG_arg_fail(1)) SWIG_fail;
19802 {
19803 PyThreadState* __tstate = wxPyBeginAllowThreads();
19804 delete arg1;
19805
19806 wxPyEndAllowThreads(__tstate);
19807 if (PyErr_Occurred()) SWIG_fail;
19808 }
19809 Py_INCREF(Py_None); resultobj = Py_None;
19810 return resultobj;
19811 fail:
19812 return NULL;
19813 }
19814
19815
19816 static PyObject *_wrap_DateTime_SetToCurrent(PyObject *, PyObject *args, PyObject *kwargs) {
19817 PyObject *resultobj;
19818 wxDateTime *arg1 = (wxDateTime *) 0 ;
19819 wxDateTime *result;
19820 PyObject * obj0 = 0 ;
19821 char *kwnames[] = {
19822 (char *) "self", NULL
19823 };
19824
19825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_SetToCurrent",kwnames,&obj0)) goto fail;
19826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19827 if (SWIG_arg_fail(1)) SWIG_fail;
19828 {
19829 PyThreadState* __tstate = wxPyBeginAllowThreads();
19830 {
19831 wxDateTime &_result_ref = (arg1)->SetToCurrent();
19832 result = (wxDateTime *) &_result_ref;
19833 }
19834
19835 wxPyEndAllowThreads(__tstate);
19836 if (PyErr_Occurred()) SWIG_fail;
19837 }
19838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19839 return resultobj;
19840 fail:
19841 return NULL;
19842 }
19843
19844
19845 static PyObject *_wrap_DateTime_SetTimeT(PyObject *, PyObject *args, PyObject *kwargs) {
19846 PyObject *resultobj;
19847 wxDateTime *arg1 = (wxDateTime *) 0 ;
19848 time_t arg2 ;
19849 wxDateTime *result;
19850 PyObject * obj0 = 0 ;
19851 PyObject * obj1 = 0 ;
19852 char *kwnames[] = {
19853 (char *) "self",(char *) "timet", NULL
19854 };
19855
19856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetTimeT",kwnames,&obj0,&obj1)) goto fail;
19857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19858 if (SWIG_arg_fail(1)) SWIG_fail;
19859 {
19860 arg2 = (time_t)(SWIG_As_unsigned_SS_int(obj1));
19861 if (SWIG_arg_fail(2)) SWIG_fail;
19862 }
19863 {
19864 PyThreadState* __tstate = wxPyBeginAllowThreads();
19865 {
19866 wxDateTime &_result_ref = (arg1)->Set(arg2);
19867 result = (wxDateTime *) &_result_ref;
19868 }
19869
19870 wxPyEndAllowThreads(__tstate);
19871 if (PyErr_Occurred()) SWIG_fail;
19872 }
19873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19874 return resultobj;
19875 fail:
19876 return NULL;
19877 }
19878
19879
19880 static PyObject *_wrap_DateTime_SetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
19881 PyObject *resultobj;
19882 wxDateTime *arg1 = (wxDateTime *) 0 ;
19883 double arg2 ;
19884 wxDateTime *result;
19885 PyObject * obj0 = 0 ;
19886 PyObject * obj1 = 0 ;
19887 char *kwnames[] = {
19888 (char *) "self",(char *) "jdn", NULL
19889 };
19890
19891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetJDN",kwnames,&obj0,&obj1)) goto fail;
19892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 {
19895 arg2 = (double)(SWIG_As_double(obj1));
19896 if (SWIG_arg_fail(2)) SWIG_fail;
19897 }
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 {
19901 wxDateTime &_result_ref = (arg1)->Set(arg2);
19902 result = (wxDateTime *) &_result_ref;
19903 }
19904
19905 wxPyEndAllowThreads(__tstate);
19906 if (PyErr_Occurred()) SWIG_fail;
19907 }
19908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19909 return resultobj;
19910 fail:
19911 return NULL;
19912 }
19913
19914
19915 static PyObject *_wrap_DateTime_SetHMS(PyObject *, PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj;
19917 wxDateTime *arg1 = (wxDateTime *) 0 ;
19918 int arg2 ;
19919 int arg3 = (int) 0 ;
19920 int arg4 = (int) 0 ;
19921 int arg5 = (int) 0 ;
19922 wxDateTime *result;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 PyObject * obj2 = 0 ;
19926 PyObject * obj3 = 0 ;
19927 PyObject * obj4 = 0 ;
19928 char *kwnames[] = {
19929 (char *) "self",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19930 };
19931
19932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetHMS",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
19933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19934 if (SWIG_arg_fail(1)) SWIG_fail;
19935 {
19936 arg2 = (int)(SWIG_As_int(obj1));
19937 if (SWIG_arg_fail(2)) SWIG_fail;
19938 }
19939 if (obj2) {
19940 {
19941 arg3 = (int)(SWIG_As_int(obj2));
19942 if (SWIG_arg_fail(3)) SWIG_fail;
19943 }
19944 }
19945 if (obj3) {
19946 {
19947 arg4 = (int)(SWIG_As_int(obj3));
19948 if (SWIG_arg_fail(4)) SWIG_fail;
19949 }
19950 }
19951 if (obj4) {
19952 {
19953 arg5 = (int)(SWIG_As_int(obj4));
19954 if (SWIG_arg_fail(5)) SWIG_fail;
19955 }
19956 }
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 {
19960 wxDateTime &_result_ref = (arg1)->Set(arg2,arg3,arg4,arg5);
19961 result = (wxDateTime *) &_result_ref;
19962 }
19963
19964 wxPyEndAllowThreads(__tstate);
19965 if (PyErr_Occurred()) SWIG_fail;
19966 }
19967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
19968 return resultobj;
19969 fail:
19970 return NULL;
19971 }
19972
19973
19974 static PyObject *_wrap_DateTime_Set(PyObject *, PyObject *args, PyObject *kwargs) {
19975 PyObject *resultobj;
19976 wxDateTime *arg1 = (wxDateTime *) 0 ;
19977 int arg2 ;
19978 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
19979 int arg4 = (int) wxDateTime::Inv_Year ;
19980 int arg5 = (int) 0 ;
19981 int arg6 = (int) 0 ;
19982 int arg7 = (int) 0 ;
19983 int arg8 = (int) 0 ;
19984 wxDateTime *result;
19985 PyObject * obj0 = 0 ;
19986 PyObject * obj1 = 0 ;
19987 PyObject * obj2 = 0 ;
19988 PyObject * obj3 = 0 ;
19989 PyObject * obj4 = 0 ;
19990 PyObject * obj5 = 0 ;
19991 PyObject * obj6 = 0 ;
19992 PyObject * obj7 = 0 ;
19993 char *kwnames[] = {
19994 (char *) "self",(char *) "day",(char *) "month",(char *) "year",(char *) "hour",(char *) "minute",(char *) "second",(char *) "millisec", NULL
19995 };
19996
19997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:DateTime_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
19998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
19999 if (SWIG_arg_fail(1)) SWIG_fail;
20000 {
20001 arg2 = (int)(SWIG_As_int(obj1));
20002 if (SWIG_arg_fail(2)) SWIG_fail;
20003 }
20004 if (obj2) {
20005 {
20006 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20007 if (SWIG_arg_fail(3)) SWIG_fail;
20008 }
20009 }
20010 if (obj3) {
20011 {
20012 arg4 = (int)(SWIG_As_int(obj3));
20013 if (SWIG_arg_fail(4)) SWIG_fail;
20014 }
20015 }
20016 if (obj4) {
20017 {
20018 arg5 = (int)(SWIG_As_int(obj4));
20019 if (SWIG_arg_fail(5)) SWIG_fail;
20020 }
20021 }
20022 if (obj5) {
20023 {
20024 arg6 = (int)(SWIG_As_int(obj5));
20025 if (SWIG_arg_fail(6)) SWIG_fail;
20026 }
20027 }
20028 if (obj6) {
20029 {
20030 arg7 = (int)(SWIG_As_int(obj6));
20031 if (SWIG_arg_fail(7)) SWIG_fail;
20032 }
20033 }
20034 if (obj7) {
20035 {
20036 arg8 = (int)(SWIG_As_int(obj7));
20037 if (SWIG_arg_fail(8)) SWIG_fail;
20038 }
20039 }
20040 {
20041 PyThreadState* __tstate = wxPyBeginAllowThreads();
20042 {
20043 wxDateTime &_result_ref = (arg1)->Set(arg2,(wxDateTime::Month )arg3,arg4,arg5,arg6,arg7,arg8);
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_ResetTime(PyObject *, PyObject *args, PyObject *kwargs) {
20058 PyObject *resultobj;
20059 wxDateTime *arg1 = (wxDateTime *) 0 ;
20060 wxDateTime *result;
20061 PyObject * obj0 = 0 ;
20062 char *kwnames[] = {
20063 (char *) "self", NULL
20064 };
20065
20066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_ResetTime",kwnames,&obj0)) goto fail;
20067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20068 if (SWIG_arg_fail(1)) SWIG_fail;
20069 {
20070 PyThreadState* __tstate = wxPyBeginAllowThreads();
20071 {
20072 wxDateTime &_result_ref = (arg1)->ResetTime();
20073 result = (wxDateTime *) &_result_ref;
20074 }
20075
20076 wxPyEndAllowThreads(__tstate);
20077 if (PyErr_Occurred()) SWIG_fail;
20078 }
20079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20080 return resultobj;
20081 fail:
20082 return NULL;
20083 }
20084
20085
20086 static PyObject *_wrap_DateTime_SetYear(PyObject *, PyObject *args, PyObject *kwargs) {
20087 PyObject *resultobj;
20088 wxDateTime *arg1 = (wxDateTime *) 0 ;
20089 int arg2 ;
20090 wxDateTime *result;
20091 PyObject * obj0 = 0 ;
20092 PyObject * obj1 = 0 ;
20093 char *kwnames[] = {
20094 (char *) "self",(char *) "year", NULL
20095 };
20096
20097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetYear",kwnames,&obj0,&obj1)) goto fail;
20098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20099 if (SWIG_arg_fail(1)) SWIG_fail;
20100 {
20101 arg2 = (int)(SWIG_As_int(obj1));
20102 if (SWIG_arg_fail(2)) SWIG_fail;
20103 }
20104 {
20105 PyThreadState* __tstate = wxPyBeginAllowThreads();
20106 {
20107 wxDateTime &_result_ref = (arg1)->SetYear(arg2);
20108 result = (wxDateTime *) &_result_ref;
20109 }
20110
20111 wxPyEndAllowThreads(__tstate);
20112 if (PyErr_Occurred()) SWIG_fail;
20113 }
20114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20115 return resultobj;
20116 fail:
20117 return NULL;
20118 }
20119
20120
20121 static PyObject *_wrap_DateTime_SetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
20122 PyObject *resultobj;
20123 wxDateTime *arg1 = (wxDateTime *) 0 ;
20124 wxDateTime::Month arg2 ;
20125 wxDateTime *result;
20126 PyObject * obj0 = 0 ;
20127 PyObject * obj1 = 0 ;
20128 char *kwnames[] = {
20129 (char *) "self",(char *) "month", NULL
20130 };
20131
20132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMonth",kwnames,&obj0,&obj1)) goto fail;
20133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20134 if (SWIG_arg_fail(1)) SWIG_fail;
20135 {
20136 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20137 if (SWIG_arg_fail(2)) SWIG_fail;
20138 }
20139 {
20140 PyThreadState* __tstate = wxPyBeginAllowThreads();
20141 {
20142 wxDateTime &_result_ref = (arg1)->SetMonth((wxDateTime::Month )arg2);
20143 result = (wxDateTime *) &_result_ref;
20144 }
20145
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20150 return resultobj;
20151 fail:
20152 return NULL;
20153 }
20154
20155
20156 static PyObject *_wrap_DateTime_SetDay(PyObject *, PyObject *args, PyObject *kwargs) {
20157 PyObject *resultobj;
20158 wxDateTime *arg1 = (wxDateTime *) 0 ;
20159 int arg2 ;
20160 wxDateTime *result;
20161 PyObject * obj0 = 0 ;
20162 PyObject * obj1 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self",(char *) "day", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetDay",kwnames,&obj0,&obj1)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 arg2 = (int)(SWIG_As_int(obj1));
20172 if (SWIG_arg_fail(2)) SWIG_fail;
20173 }
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 {
20177 wxDateTime &_result_ref = (arg1)->SetDay(arg2);
20178 result = (wxDateTime *) &_result_ref;
20179 }
20180
20181 wxPyEndAllowThreads(__tstate);
20182 if (PyErr_Occurred()) SWIG_fail;
20183 }
20184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20185 return resultobj;
20186 fail:
20187 return NULL;
20188 }
20189
20190
20191 static PyObject *_wrap_DateTime_SetHour(PyObject *, PyObject *args, PyObject *kwargs) {
20192 PyObject *resultobj;
20193 wxDateTime *arg1 = (wxDateTime *) 0 ;
20194 int arg2 ;
20195 wxDateTime *result;
20196 PyObject * obj0 = 0 ;
20197 PyObject * obj1 = 0 ;
20198 char *kwnames[] = {
20199 (char *) "self",(char *) "hour", NULL
20200 };
20201
20202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetHour",kwnames,&obj0,&obj1)) goto fail;
20203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20204 if (SWIG_arg_fail(1)) SWIG_fail;
20205 {
20206 arg2 = (int)(SWIG_As_int(obj1));
20207 if (SWIG_arg_fail(2)) SWIG_fail;
20208 }
20209 {
20210 PyThreadState* __tstate = wxPyBeginAllowThreads();
20211 {
20212 wxDateTime &_result_ref = (arg1)->SetHour(arg2);
20213 result = (wxDateTime *) &_result_ref;
20214 }
20215
20216 wxPyEndAllowThreads(__tstate);
20217 if (PyErr_Occurred()) SWIG_fail;
20218 }
20219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 static PyObject *_wrap_DateTime_SetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
20227 PyObject *resultobj;
20228 wxDateTime *arg1 = (wxDateTime *) 0 ;
20229 int arg2 ;
20230 wxDateTime *result;
20231 PyObject * obj0 = 0 ;
20232 PyObject * obj1 = 0 ;
20233 char *kwnames[] = {
20234 (char *) "self",(char *) "minute", NULL
20235 };
20236
20237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMinute",kwnames,&obj0,&obj1)) goto fail;
20238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20239 if (SWIG_arg_fail(1)) SWIG_fail;
20240 {
20241 arg2 = (int)(SWIG_As_int(obj1));
20242 if (SWIG_arg_fail(2)) SWIG_fail;
20243 }
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 {
20247 wxDateTime &_result_ref = (arg1)->SetMinute(arg2);
20248 result = (wxDateTime *) &_result_ref;
20249 }
20250
20251 wxPyEndAllowThreads(__tstate);
20252 if (PyErr_Occurred()) SWIG_fail;
20253 }
20254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20255 return resultobj;
20256 fail:
20257 return NULL;
20258 }
20259
20260
20261 static PyObject *_wrap_DateTime_SetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
20262 PyObject *resultobj;
20263 wxDateTime *arg1 = (wxDateTime *) 0 ;
20264 int arg2 ;
20265 wxDateTime *result;
20266 PyObject * obj0 = 0 ;
20267 PyObject * obj1 = 0 ;
20268 char *kwnames[] = {
20269 (char *) "self",(char *) "second", NULL
20270 };
20271
20272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetSecond",kwnames,&obj0,&obj1)) goto fail;
20273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20274 if (SWIG_arg_fail(1)) SWIG_fail;
20275 {
20276 arg2 = (int)(SWIG_As_int(obj1));
20277 if (SWIG_arg_fail(2)) SWIG_fail;
20278 }
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 {
20282 wxDateTime &_result_ref = (arg1)->SetSecond(arg2);
20283 result = (wxDateTime *) &_result_ref;
20284 }
20285
20286 wxPyEndAllowThreads(__tstate);
20287 if (PyErr_Occurred()) SWIG_fail;
20288 }
20289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20290 return resultobj;
20291 fail:
20292 return NULL;
20293 }
20294
20295
20296 static PyObject *_wrap_DateTime_SetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
20297 PyObject *resultobj;
20298 wxDateTime *arg1 = (wxDateTime *) 0 ;
20299 int arg2 ;
20300 wxDateTime *result;
20301 PyObject * obj0 = 0 ;
20302 PyObject * obj1 = 0 ;
20303 char *kwnames[] = {
20304 (char *) "self",(char *) "millisecond", NULL
20305 };
20306
20307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetMillisecond",kwnames,&obj0,&obj1)) goto fail;
20308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20309 if (SWIG_arg_fail(1)) SWIG_fail;
20310 {
20311 arg2 = (int)(SWIG_As_int(obj1));
20312 if (SWIG_arg_fail(2)) SWIG_fail;
20313 }
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 {
20317 wxDateTime &_result_ref = (arg1)->SetMillisecond(arg2);
20318 result = (wxDateTime *) &_result_ref;
20319 }
20320
20321 wxPyEndAllowThreads(__tstate);
20322 if (PyErr_Occurred()) SWIG_fail;
20323 }
20324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20325 return resultobj;
20326 fail:
20327 return NULL;
20328 }
20329
20330
20331 static PyObject *_wrap_DateTime_SetToWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20332 PyObject *resultobj;
20333 wxDateTime *arg1 = (wxDateTime *) 0 ;
20334 wxDateTime::WeekDay arg2 ;
20335 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20336 wxDateTime *result;
20337 PyObject * obj0 = 0 ;
20338 PyObject * obj1 = 0 ;
20339 PyObject * obj2 = 0 ;
20340 char *kwnames[] = {
20341 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20342 };
20343
20344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20346 if (SWIG_arg_fail(1)) SWIG_fail;
20347 {
20348 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20349 if (SWIG_arg_fail(2)) SWIG_fail;
20350 }
20351 if (obj2) {
20352 {
20353 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20354 if (SWIG_arg_fail(3)) SWIG_fail;
20355 }
20356 }
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 {
20360 wxDateTime &_result_ref = (arg1)->SetToWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20361 result = (wxDateTime *) &_result_ref;
20362 }
20363
20364 wxPyEndAllowThreads(__tstate);
20365 if (PyErr_Occurred()) SWIG_fail;
20366 }
20367 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20368 return resultobj;
20369 fail:
20370 return NULL;
20371 }
20372
20373
20374 static PyObject *_wrap_DateTime_GetWeekDayInSameWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20375 PyObject *resultobj;
20376 wxDateTime *arg1 = (wxDateTime *) 0 ;
20377 wxDateTime::WeekDay arg2 ;
20378 wxDateTime::WeekFlags arg3 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20379 wxDateTime result;
20380 PyObject * obj0 = 0 ;
20381 PyObject * obj1 = 0 ;
20382 PyObject * obj2 = 0 ;
20383 char *kwnames[] = {
20384 (char *) "self",(char *) "weekday",(char *) "flags", NULL
20385 };
20386
20387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_GetWeekDayInSameWeek",kwnames,&obj0,&obj1,&obj2)) goto fail;
20388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20389 if (SWIG_arg_fail(1)) SWIG_fail;
20390 {
20391 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20392 if (SWIG_arg_fail(2)) SWIG_fail;
20393 }
20394 if (obj2) {
20395 {
20396 arg3 = (wxDateTime::WeekFlags)(SWIG_As_int(obj2));
20397 if (SWIG_arg_fail(3)) SWIG_fail;
20398 }
20399 }
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (arg1)->GetWeekDayInSameWeek((wxDateTime::WeekDay )arg2,(wxDateTime::WeekFlags )arg3);
20403
20404 wxPyEndAllowThreads(__tstate);
20405 if (PyErr_Occurred()) SWIG_fail;
20406 }
20407 {
20408 wxDateTime * resultptr;
20409 resultptr = new wxDateTime((wxDateTime &)(result));
20410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20411 }
20412 return resultobj;
20413 fail:
20414 return NULL;
20415 }
20416
20417
20418 static PyObject *_wrap_DateTime_SetToNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20419 PyObject *resultobj;
20420 wxDateTime *arg1 = (wxDateTime *) 0 ;
20421 wxDateTime::WeekDay arg2 ;
20422 wxDateTime *result;
20423 PyObject * obj0 = 0 ;
20424 PyObject * obj1 = 0 ;
20425 char *kwnames[] = {
20426 (char *) "self",(char *) "weekday", NULL
20427 };
20428
20429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20431 if (SWIG_arg_fail(1)) SWIG_fail;
20432 {
20433 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20434 if (SWIG_arg_fail(2)) SWIG_fail;
20435 }
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 {
20439 wxDateTime &_result_ref = (arg1)->SetToNextWeekDay((wxDateTime::WeekDay )arg2);
20440 result = (wxDateTime *) &_result_ref;
20441 }
20442
20443 wxPyEndAllowThreads(__tstate);
20444 if (PyErr_Occurred()) SWIG_fail;
20445 }
20446 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20447 return resultobj;
20448 fail:
20449 return NULL;
20450 }
20451
20452
20453 static PyObject *_wrap_DateTime_GetNextWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20454 PyObject *resultobj;
20455 wxDateTime *arg1 = (wxDateTime *) 0 ;
20456 wxDateTime::WeekDay arg2 ;
20457 wxDateTime result;
20458 PyObject * obj0 = 0 ;
20459 PyObject * obj1 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "self",(char *) "weekday", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetNextWeekDay",kwnames,&obj0,&obj1)) goto fail;
20465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20466 if (SWIG_arg_fail(1)) SWIG_fail;
20467 {
20468 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20469 if (SWIG_arg_fail(2)) SWIG_fail;
20470 }
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (arg1)->GetNextWeekDay((wxDateTime::WeekDay )arg2);
20474
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 {
20479 wxDateTime * resultptr;
20480 resultptr = new wxDateTime((wxDateTime &)(result));
20481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20482 }
20483 return resultobj;
20484 fail:
20485 return NULL;
20486 }
20487
20488
20489 static PyObject *_wrap_DateTime_SetToPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20490 PyObject *resultobj;
20491 wxDateTime *arg1 = (wxDateTime *) 0 ;
20492 wxDateTime::WeekDay arg2 ;
20493 wxDateTime *result;
20494 PyObject * obj0 = 0 ;
20495 PyObject * obj1 = 0 ;
20496 char *kwnames[] = {
20497 (char *) "self",(char *) "weekday", NULL
20498 };
20499
20500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20502 if (SWIG_arg_fail(1)) SWIG_fail;
20503 {
20504 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20505 if (SWIG_arg_fail(2)) SWIG_fail;
20506 }
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 {
20510 wxDateTime &_result_ref = (arg1)->SetToPrevWeekDay((wxDateTime::WeekDay )arg2);
20511 result = (wxDateTime *) &_result_ref;
20512 }
20513
20514 wxPyEndAllowThreads(__tstate);
20515 if (PyErr_Occurred()) SWIG_fail;
20516 }
20517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20518 return resultobj;
20519 fail:
20520 return NULL;
20521 }
20522
20523
20524 static PyObject *_wrap_DateTime_GetPrevWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20525 PyObject *resultobj;
20526 wxDateTime *arg1 = (wxDateTime *) 0 ;
20527 wxDateTime::WeekDay arg2 ;
20528 wxDateTime result;
20529 PyObject * obj0 = 0 ;
20530 PyObject * obj1 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "self",(char *) "weekday", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetPrevWeekDay",kwnames,&obj0,&obj1)) goto fail;
20536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20537 if (SWIG_arg_fail(1)) SWIG_fail;
20538 {
20539 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20540 if (SWIG_arg_fail(2)) SWIG_fail;
20541 }
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (arg1)->GetPrevWeekDay((wxDateTime::WeekDay )arg2);
20545
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 {
20550 wxDateTime * resultptr;
20551 resultptr = new wxDateTime((wxDateTime &)(result));
20552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20553 }
20554 return resultobj;
20555 fail:
20556 return NULL;
20557 }
20558
20559
20560 static PyObject *_wrap_DateTime_SetToWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20561 PyObject *resultobj;
20562 wxDateTime *arg1 = (wxDateTime *) 0 ;
20563 wxDateTime::WeekDay arg2 ;
20564 int arg3 = (int) 1 ;
20565 wxDateTime::Month arg4 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20566 int arg5 = (int) wxDateTime::Inv_Year ;
20567 bool result;
20568 PyObject * obj0 = 0 ;
20569 PyObject * obj1 = 0 ;
20570 PyObject * obj2 = 0 ;
20571 PyObject * obj3 = 0 ;
20572 PyObject * obj4 = 0 ;
20573 char *kwnames[] = {
20574 (char *) "self",(char *) "weekday",(char *) "n",(char *) "month",(char *) "year", NULL
20575 };
20576
20577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:DateTime_SetToWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
20578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20579 if (SWIG_arg_fail(1)) SWIG_fail;
20580 {
20581 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20582 if (SWIG_arg_fail(2)) SWIG_fail;
20583 }
20584 if (obj2) {
20585 {
20586 arg3 = (int)(SWIG_As_int(obj2));
20587 if (SWIG_arg_fail(3)) SWIG_fail;
20588 }
20589 }
20590 if (obj3) {
20591 {
20592 arg4 = (wxDateTime::Month)(SWIG_As_int(obj3));
20593 if (SWIG_arg_fail(4)) SWIG_fail;
20594 }
20595 }
20596 if (obj4) {
20597 {
20598 arg5 = (int)(SWIG_As_int(obj4));
20599 if (SWIG_arg_fail(5)) SWIG_fail;
20600 }
20601 }
20602 {
20603 PyThreadState* __tstate = wxPyBeginAllowThreads();
20604 result = (bool)(arg1)->SetToWeekDay((wxDateTime::WeekDay )arg2,arg3,(wxDateTime::Month )arg4,arg5);
20605
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 {
20610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20611 }
20612 return resultobj;
20613 fail:
20614 return NULL;
20615 }
20616
20617
20618 static PyObject *_wrap_DateTime_SetToLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20619 PyObject *resultobj;
20620 wxDateTime *arg1 = (wxDateTime *) 0 ;
20621 wxDateTime::WeekDay arg2 ;
20622 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20623 int arg4 = (int) wxDateTime::Inv_Year ;
20624 bool result;
20625 PyObject * obj0 = 0 ;
20626 PyObject * obj1 = 0 ;
20627 PyObject * obj2 = 0 ;
20628 PyObject * obj3 = 0 ;
20629 char *kwnames[] = {
20630 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20631 };
20632
20633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20635 if (SWIG_arg_fail(1)) SWIG_fail;
20636 {
20637 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20638 if (SWIG_arg_fail(2)) SWIG_fail;
20639 }
20640 if (obj2) {
20641 {
20642 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20643 if (SWIG_arg_fail(3)) SWIG_fail;
20644 }
20645 }
20646 if (obj3) {
20647 {
20648 arg4 = (int)(SWIG_As_int(obj3));
20649 if (SWIG_arg_fail(4)) SWIG_fail;
20650 }
20651 }
20652 {
20653 PyThreadState* __tstate = wxPyBeginAllowThreads();
20654 result = (bool)(arg1)->SetToLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20655
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 {
20660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20661 }
20662 return resultobj;
20663 fail:
20664 return NULL;
20665 }
20666
20667
20668 static PyObject *_wrap_DateTime_GetLastWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
20669 PyObject *resultobj;
20670 wxDateTime *arg1 = (wxDateTime *) 0 ;
20671 wxDateTime::WeekDay arg2 ;
20672 wxDateTime::Month arg3 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20673 int arg4 = (int) wxDateTime::Inv_Year ;
20674 wxDateTime result;
20675 PyObject * obj0 = 0 ;
20676 PyObject * obj1 = 0 ;
20677 PyObject * obj2 = 0 ;
20678 PyObject * obj3 = 0 ;
20679 char *kwnames[] = {
20680 (char *) "self",(char *) "weekday",(char *) "month",(char *) "year", NULL
20681 };
20682
20683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetLastWeekDay",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20685 if (SWIG_arg_fail(1)) SWIG_fail;
20686 {
20687 arg2 = (wxDateTime::WeekDay)(SWIG_As_int(obj1));
20688 if (SWIG_arg_fail(2)) SWIG_fail;
20689 }
20690 if (obj2) {
20691 {
20692 arg3 = (wxDateTime::Month)(SWIG_As_int(obj2));
20693 if (SWIG_arg_fail(3)) SWIG_fail;
20694 }
20695 }
20696 if (obj3) {
20697 {
20698 arg4 = (int)(SWIG_As_int(obj3));
20699 if (SWIG_arg_fail(4)) SWIG_fail;
20700 }
20701 }
20702 {
20703 PyThreadState* __tstate = wxPyBeginAllowThreads();
20704 result = (arg1)->GetLastWeekDay((wxDateTime::WeekDay )arg2,(wxDateTime::Month )arg3,arg4);
20705
20706 wxPyEndAllowThreads(__tstate);
20707 if (PyErr_Occurred()) SWIG_fail;
20708 }
20709 {
20710 wxDateTime * resultptr;
20711 resultptr = new wxDateTime((wxDateTime &)(result));
20712 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20713 }
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 static PyObject *_wrap_DateTime_SetToTheWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20721 PyObject *resultobj;
20722 wxDateTime *arg1 = (wxDateTime *) 0 ;
20723 int arg2 ;
20724 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20725 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20726 bool result;
20727 PyObject * obj0 = 0 ;
20728 PyObject * obj1 = 0 ;
20729 PyObject * obj2 = 0 ;
20730 PyObject * obj3 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_SetToTheWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 arg2 = (int)(SWIG_As_int(obj1));
20740 if (SWIG_arg_fail(2)) SWIG_fail;
20741 }
20742 if (obj2) {
20743 {
20744 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20745 if (SWIG_arg_fail(3)) SWIG_fail;
20746 }
20747 }
20748 if (obj3) {
20749 {
20750 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20751 if (SWIG_arg_fail(4)) SWIG_fail;
20752 }
20753 }
20754 {
20755 PyThreadState* __tstate = wxPyBeginAllowThreads();
20756 result = (bool)(arg1)->SetToTheWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20757
20758 wxPyEndAllowThreads(__tstate);
20759 if (PyErr_Occurred()) SWIG_fail;
20760 }
20761 {
20762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20763 }
20764 return resultobj;
20765 fail:
20766 return NULL;
20767 }
20768
20769
20770 static PyObject *_wrap_DateTime_GetWeek(PyObject *, PyObject *args, PyObject *kwargs) {
20771 PyObject *resultobj;
20772 wxDateTime *arg1 = (wxDateTime *) 0 ;
20773 int arg2 ;
20774 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20775 wxDateTime::WeekFlags arg4 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
20776 wxDateTime result;
20777 PyObject * obj0 = 0 ;
20778 PyObject * obj1 = 0 ;
20779 PyObject * obj2 = 0 ;
20780 PyObject * obj3 = 0 ;
20781 char *kwnames[] = {
20782 (char *) "self",(char *) "numWeek",(char *) "weekday",(char *) "flags", NULL
20783 };
20784
20785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_GetWeek",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
20786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20787 if (SWIG_arg_fail(1)) SWIG_fail;
20788 {
20789 arg2 = (int)(SWIG_As_int(obj1));
20790 if (SWIG_arg_fail(2)) SWIG_fail;
20791 }
20792 if (obj2) {
20793 {
20794 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20795 if (SWIG_arg_fail(3)) SWIG_fail;
20796 }
20797 }
20798 if (obj3) {
20799 {
20800 arg4 = (wxDateTime::WeekFlags)(SWIG_As_int(obj3));
20801 if (SWIG_arg_fail(4)) SWIG_fail;
20802 }
20803 }
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (arg1)->GetWeek(arg2,(wxDateTime::WeekDay )arg3,(wxDateTime::WeekFlags )arg4);
20807
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 {
20812 wxDateTime * resultptr;
20813 resultptr = new wxDateTime((wxDateTime &)(result));
20814 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20815 }
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 static PyObject *_wrap_DateTime_SetToWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
20823 PyObject *resultobj;
20824 int arg1 ;
20825 int arg2 ;
20826 wxDateTime::WeekDay arg3 = (wxDateTime::WeekDay) wxDateTime::Mon ;
20827 wxDateTime result;
20828 PyObject * obj0 = 0 ;
20829 PyObject * obj1 = 0 ;
20830 PyObject * obj2 = 0 ;
20831 char *kwnames[] = {
20832 (char *) "year",(char *) "numWeek",(char *) "weekday", NULL
20833 };
20834
20835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_SetToWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
20836 {
20837 arg1 = (int)(SWIG_As_int(obj0));
20838 if (SWIG_arg_fail(1)) SWIG_fail;
20839 }
20840 {
20841 arg2 = (int)(SWIG_As_int(obj1));
20842 if (SWIG_arg_fail(2)) SWIG_fail;
20843 }
20844 if (obj2) {
20845 {
20846 arg3 = (wxDateTime::WeekDay)(SWIG_As_int(obj2));
20847 if (SWIG_arg_fail(3)) SWIG_fail;
20848 }
20849 }
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = wxDateTime::SetToWeekOfYear(arg1,arg2,(wxDateTime::WeekDay )arg3);
20853
20854 wxPyEndAllowThreads(__tstate);
20855 if (PyErr_Occurred()) SWIG_fail;
20856 }
20857 {
20858 wxDateTime * resultptr;
20859 resultptr = new wxDateTime((wxDateTime &)(result));
20860 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20861 }
20862 return resultobj;
20863 fail:
20864 return NULL;
20865 }
20866
20867
20868 static PyObject *_wrap_DateTime_SetToLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20869 PyObject *resultobj;
20870 wxDateTime *arg1 = (wxDateTime *) 0 ;
20871 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20872 int arg3 = (int) wxDateTime::Inv_Year ;
20873 wxDateTime *result;
20874 PyObject * obj0 = 0 ;
20875 PyObject * obj1 = 0 ;
20876 PyObject * obj2 = 0 ;
20877 char *kwnames[] = {
20878 (char *) "self",(char *) "month",(char *) "year", NULL
20879 };
20880
20881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_SetToLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20883 if (SWIG_arg_fail(1)) SWIG_fail;
20884 if (obj1) {
20885 {
20886 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20887 if (SWIG_arg_fail(2)) SWIG_fail;
20888 }
20889 }
20890 if (obj2) {
20891 {
20892 arg3 = (int)(SWIG_As_int(obj2));
20893 if (SWIG_arg_fail(3)) SWIG_fail;
20894 }
20895 }
20896 {
20897 PyThreadState* __tstate = wxPyBeginAllowThreads();
20898 {
20899 wxDateTime &_result_ref = (arg1)->SetToLastMonthDay((wxDateTime::Month )arg2,arg3);
20900 result = (wxDateTime *) &_result_ref;
20901 }
20902
20903 wxPyEndAllowThreads(__tstate);
20904 if (PyErr_Occurred()) SWIG_fail;
20905 }
20906 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20907 return resultobj;
20908 fail:
20909 return NULL;
20910 }
20911
20912
20913 static PyObject *_wrap_DateTime_GetLastMonthDay(PyObject *, PyObject *args, PyObject *kwargs) {
20914 PyObject *resultobj;
20915 wxDateTime *arg1 = (wxDateTime *) 0 ;
20916 wxDateTime::Month arg2 = (wxDateTime::Month) wxDateTime::Inv_Month ;
20917 int arg3 = (int) wxDateTime::Inv_Year ;
20918 wxDateTime result;
20919 PyObject * obj0 = 0 ;
20920 PyObject * obj1 = 0 ;
20921 PyObject * obj2 = 0 ;
20922 char *kwnames[] = {
20923 (char *) "self",(char *) "month",(char *) "year", NULL
20924 };
20925
20926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetLastMonthDay",kwnames,&obj0,&obj1,&obj2)) goto fail;
20927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20928 if (SWIG_arg_fail(1)) SWIG_fail;
20929 if (obj1) {
20930 {
20931 arg2 = (wxDateTime::Month)(SWIG_As_int(obj1));
20932 if (SWIG_arg_fail(2)) SWIG_fail;
20933 }
20934 }
20935 if (obj2) {
20936 {
20937 arg3 = (int)(SWIG_As_int(obj2));
20938 if (SWIG_arg_fail(3)) SWIG_fail;
20939 }
20940 }
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 result = (arg1)->GetLastMonthDay((wxDateTime::Month )arg2,arg3);
20944
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 {
20949 wxDateTime * resultptr;
20950 resultptr = new wxDateTime((wxDateTime &)(result));
20951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
20952 }
20953 return resultobj;
20954 fail:
20955 return NULL;
20956 }
20957
20958
20959 static PyObject *_wrap_DateTime_SetToYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20960 PyObject *resultobj;
20961 wxDateTime *arg1 = (wxDateTime *) 0 ;
20962 int arg2 ;
20963 wxDateTime *result;
20964 PyObject * obj0 = 0 ;
20965 PyObject * obj1 = 0 ;
20966 char *kwnames[] = {
20967 (char *) "self",(char *) "yday", NULL
20968 };
20969
20970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SetToYearDay",kwnames,&obj0,&obj1)) goto fail;
20971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
20972 if (SWIG_arg_fail(1)) SWIG_fail;
20973 {
20974 arg2 = (int)(SWIG_As_int(obj1));
20975 if (SWIG_arg_fail(2)) SWIG_fail;
20976 }
20977 {
20978 PyThreadState* __tstate = wxPyBeginAllowThreads();
20979 {
20980 wxDateTime &_result_ref = (arg1)->SetToYearDay(arg2);
20981 result = (wxDateTime *) &_result_ref;
20982 }
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
20988 return resultobj;
20989 fail:
20990 return NULL;
20991 }
20992
20993
20994 static PyObject *_wrap_DateTime_GetYearDay(PyObject *, PyObject *args, PyObject *kwargs) {
20995 PyObject *resultobj;
20996 wxDateTime *arg1 = (wxDateTime *) 0 ;
20997 int arg2 ;
20998 wxDateTime result;
20999 PyObject * obj0 = 0 ;
21000 PyObject * obj1 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self",(char *) "yday", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_GetYearDay",kwnames,&obj0,&obj1)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 arg2 = (int)(SWIG_As_int(obj1));
21010 if (SWIG_arg_fail(2)) SWIG_fail;
21011 }
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 result = (arg1)->GetYearDay(arg2);
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 {
21020 wxDateTime * resultptr;
21021 resultptr = new wxDateTime((wxDateTime &)(result));
21022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 static PyObject *_wrap_DateTime_GetJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj;
21032 wxDateTime *arg1 = (wxDateTime *) 0 ;
21033 double result;
21034 PyObject * obj0 = 0 ;
21035 char *kwnames[] = {
21036 (char *) "self", NULL
21037 };
21038
21039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJulianDayNumber",kwnames,&obj0)) goto fail;
21040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21041 if (SWIG_arg_fail(1)) SWIG_fail;
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = (double)(arg1)->GetJulianDayNumber();
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 {
21050 resultobj = SWIG_From_double((double)(result));
21051 }
21052 return resultobj;
21053 fail:
21054 return NULL;
21055 }
21056
21057
21058 static PyObject *_wrap_DateTime_GetJDN(PyObject *, PyObject *args, PyObject *kwargs) {
21059 PyObject *resultobj;
21060 wxDateTime *arg1 = (wxDateTime *) 0 ;
21061 double result;
21062 PyObject * obj0 = 0 ;
21063 char *kwnames[] = {
21064 (char *) "self", NULL
21065 };
21066
21067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetJDN",kwnames,&obj0)) goto fail;
21068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21069 if (SWIG_arg_fail(1)) SWIG_fail;
21070 {
21071 PyThreadState* __tstate = wxPyBeginAllowThreads();
21072 result = (double)(arg1)->GetJDN();
21073
21074 wxPyEndAllowThreads(__tstate);
21075 if (PyErr_Occurred()) SWIG_fail;
21076 }
21077 {
21078 resultobj = SWIG_From_double((double)(result));
21079 }
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 static PyObject *_wrap_DateTime_GetModifiedJulianDayNumber(PyObject *, PyObject *args, PyObject *kwargs) {
21087 PyObject *resultobj;
21088 wxDateTime *arg1 = (wxDateTime *) 0 ;
21089 double result;
21090 PyObject * obj0 = 0 ;
21091 char *kwnames[] = {
21092 (char *) "self", NULL
21093 };
21094
21095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetModifiedJulianDayNumber",kwnames,&obj0)) goto fail;
21096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21097 if (SWIG_arg_fail(1)) SWIG_fail;
21098 {
21099 PyThreadState* __tstate = wxPyBeginAllowThreads();
21100 result = (double)((wxDateTime const *)arg1)->GetModifiedJulianDayNumber();
21101
21102 wxPyEndAllowThreads(__tstate);
21103 if (PyErr_Occurred()) SWIG_fail;
21104 }
21105 {
21106 resultobj = SWIG_From_double((double)(result));
21107 }
21108 return resultobj;
21109 fail:
21110 return NULL;
21111 }
21112
21113
21114 static PyObject *_wrap_DateTime_GetMJD(PyObject *, PyObject *args, PyObject *kwargs) {
21115 PyObject *resultobj;
21116 wxDateTime *arg1 = (wxDateTime *) 0 ;
21117 double result;
21118 PyObject * obj0 = 0 ;
21119 char *kwnames[] = {
21120 (char *) "self", NULL
21121 };
21122
21123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetMJD",kwnames,&obj0)) goto fail;
21124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21125 if (SWIG_arg_fail(1)) SWIG_fail;
21126 {
21127 PyThreadState* __tstate = wxPyBeginAllowThreads();
21128 result = (double)(arg1)->GetMJD();
21129
21130 wxPyEndAllowThreads(__tstate);
21131 if (PyErr_Occurred()) SWIG_fail;
21132 }
21133 {
21134 resultobj = SWIG_From_double((double)(result));
21135 }
21136 return resultobj;
21137 fail:
21138 return NULL;
21139 }
21140
21141
21142 static PyObject *_wrap_DateTime_GetRataDie(PyObject *, PyObject *args, PyObject *kwargs) {
21143 PyObject *resultobj;
21144 wxDateTime *arg1 = (wxDateTime *) 0 ;
21145 double result;
21146 PyObject * obj0 = 0 ;
21147 char *kwnames[] = {
21148 (char *) "self", NULL
21149 };
21150
21151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetRataDie",kwnames,&obj0)) goto fail;
21152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21153 if (SWIG_arg_fail(1)) SWIG_fail;
21154 {
21155 PyThreadState* __tstate = wxPyBeginAllowThreads();
21156 result = (double)(arg1)->GetRataDie();
21157
21158 wxPyEndAllowThreads(__tstate);
21159 if (PyErr_Occurred()) SWIG_fail;
21160 }
21161 {
21162 resultobj = SWIG_From_double((double)(result));
21163 }
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 static PyObject *_wrap_DateTime_ToTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21171 PyObject *resultobj;
21172 wxDateTime *arg1 = (wxDateTime *) 0 ;
21173 wxDateTime::TimeZone *arg2 = 0 ;
21174 bool arg3 = (bool) false ;
21175 wxDateTime result;
21176 bool temp2 = false ;
21177 PyObject * obj0 = 0 ;
21178 PyObject * obj1 = 0 ;
21179 PyObject * obj2 = 0 ;
21180 char *kwnames[] = {
21181 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21182 };
21183
21184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_ToTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21186 if (SWIG_arg_fail(1)) SWIG_fail;
21187 {
21188 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21189 temp2 = true;
21190 }
21191 if (obj2) {
21192 {
21193 arg3 = (bool)(SWIG_As_bool(obj2));
21194 if (SWIG_arg_fail(3)) SWIG_fail;
21195 }
21196 }
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (arg1)->ToTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21200
21201 wxPyEndAllowThreads(__tstate);
21202 if (PyErr_Occurred()) SWIG_fail;
21203 }
21204 {
21205 wxDateTime * resultptr;
21206 resultptr = new wxDateTime((wxDateTime &)(result));
21207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21208 }
21209 {
21210 if (temp2) delete arg2;
21211 }
21212 return resultobj;
21213 fail:
21214 {
21215 if (temp2) delete arg2;
21216 }
21217 return NULL;
21218 }
21219
21220
21221 static PyObject *_wrap_DateTime_MakeTimezone(PyObject *, PyObject *args, PyObject *kwargs) {
21222 PyObject *resultobj;
21223 wxDateTime *arg1 = (wxDateTime *) 0 ;
21224 wxDateTime::TimeZone *arg2 = 0 ;
21225 bool arg3 = (bool) false ;
21226 wxDateTime *result;
21227 bool temp2 = false ;
21228 PyObject * obj0 = 0 ;
21229 PyObject * obj1 = 0 ;
21230 PyObject * obj2 = 0 ;
21231 char *kwnames[] = {
21232 (char *) "self",(char *) "tz",(char *) "noDST", NULL
21233 };
21234
21235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DateTime_MakeTimezone",kwnames,&obj0,&obj1,&obj2)) goto fail;
21236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21237 if (SWIG_arg_fail(1)) SWIG_fail;
21238 {
21239 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21240 temp2 = true;
21241 }
21242 if (obj2) {
21243 {
21244 arg3 = (bool)(SWIG_As_bool(obj2));
21245 if (SWIG_arg_fail(3)) SWIG_fail;
21246 }
21247 }
21248 {
21249 PyThreadState* __tstate = wxPyBeginAllowThreads();
21250 {
21251 wxDateTime &_result_ref = (arg1)->MakeTimezone((wxDateTime::TimeZone const &)*arg2,arg3);
21252 result = (wxDateTime *) &_result_ref;
21253 }
21254
21255 wxPyEndAllowThreads(__tstate);
21256 if (PyErr_Occurred()) SWIG_fail;
21257 }
21258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21259 {
21260 if (temp2) delete arg2;
21261 }
21262 return resultobj;
21263 fail:
21264 {
21265 if (temp2) delete arg2;
21266 }
21267 return NULL;
21268 }
21269
21270
21271 static PyObject *_wrap_DateTime_ToGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21272 PyObject *resultobj;
21273 wxDateTime *arg1 = (wxDateTime *) 0 ;
21274 bool arg2 = (bool) false ;
21275 wxDateTime result;
21276 PyObject * obj0 = 0 ;
21277 PyObject * obj1 = 0 ;
21278 char *kwnames[] = {
21279 (char *) "self",(char *) "noDST", NULL
21280 };
21281
21282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_ToGMT",kwnames,&obj0,&obj1)) goto fail;
21283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21284 if (SWIG_arg_fail(1)) SWIG_fail;
21285 if (obj1) {
21286 {
21287 arg2 = (bool)(SWIG_As_bool(obj1));
21288 if (SWIG_arg_fail(2)) SWIG_fail;
21289 }
21290 }
21291 {
21292 PyThreadState* __tstate = wxPyBeginAllowThreads();
21293 result = (arg1)->ToGMT(arg2);
21294
21295 wxPyEndAllowThreads(__tstate);
21296 if (PyErr_Occurred()) SWIG_fail;
21297 }
21298 {
21299 wxDateTime * resultptr;
21300 resultptr = new wxDateTime((wxDateTime &)(result));
21301 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
21302 }
21303 return resultobj;
21304 fail:
21305 return NULL;
21306 }
21307
21308
21309 static PyObject *_wrap_DateTime_MakeGMT(PyObject *, PyObject *args, PyObject *kwargs) {
21310 PyObject *resultobj;
21311 wxDateTime *arg1 = (wxDateTime *) 0 ;
21312 bool arg2 = (bool) false ;
21313 wxDateTime *result;
21314 PyObject * obj0 = 0 ;
21315 PyObject * obj1 = 0 ;
21316 char *kwnames[] = {
21317 (char *) "self",(char *) "noDST", NULL
21318 };
21319
21320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_MakeGMT",kwnames,&obj0,&obj1)) goto fail;
21321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21322 if (SWIG_arg_fail(1)) SWIG_fail;
21323 if (obj1) {
21324 {
21325 arg2 = (bool)(SWIG_As_bool(obj1));
21326 if (SWIG_arg_fail(2)) SWIG_fail;
21327 }
21328 }
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 {
21332 wxDateTime &_result_ref = (arg1)->MakeGMT(arg2);
21333 result = (wxDateTime *) &_result_ref;
21334 }
21335
21336 wxPyEndAllowThreads(__tstate);
21337 if (PyErr_Occurred()) SWIG_fail;
21338 }
21339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21340 return resultobj;
21341 fail:
21342 return NULL;
21343 }
21344
21345
21346 static PyObject *_wrap_DateTime_IsDST(PyObject *, PyObject *args, PyObject *kwargs) {
21347 PyObject *resultobj;
21348 wxDateTime *arg1 = (wxDateTime *) 0 ;
21349 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21350 int result;
21351 PyObject * obj0 = 0 ;
21352 PyObject * obj1 = 0 ;
21353 char *kwnames[] = {
21354 (char *) "self",(char *) "country", NULL
21355 };
21356
21357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsDST",kwnames,&obj0,&obj1)) goto fail;
21358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21359 if (SWIG_arg_fail(1)) SWIG_fail;
21360 if (obj1) {
21361 {
21362 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21363 if (SWIG_arg_fail(2)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (int)(arg1)->IsDST((wxDateTime::Country )arg2);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 {
21374 resultobj = SWIG_From_int((int)(result));
21375 }
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_DateTime_IsValid(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj;
21384 wxDateTime *arg1 = (wxDateTime *) 0 ;
21385 bool result;
21386 PyObject * obj0 = 0 ;
21387 char *kwnames[] = {
21388 (char *) "self", NULL
21389 };
21390
21391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_IsValid",kwnames,&obj0)) goto fail;
21392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21393 if (SWIG_arg_fail(1)) SWIG_fail;
21394 {
21395 PyThreadState* __tstate = wxPyBeginAllowThreads();
21396 result = (bool)((wxDateTime const *)arg1)->IsValid();
21397
21398 wxPyEndAllowThreads(__tstate);
21399 if (PyErr_Occurred()) SWIG_fail;
21400 }
21401 {
21402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21403 }
21404 return resultobj;
21405 fail:
21406 return NULL;
21407 }
21408
21409
21410 static PyObject *_wrap_DateTime_GetTicks(PyObject *, PyObject *args, PyObject *kwargs) {
21411 PyObject *resultobj;
21412 wxDateTime *arg1 = (wxDateTime *) 0 ;
21413 time_t result;
21414 PyObject * obj0 = 0 ;
21415 char *kwnames[] = {
21416 (char *) "self", NULL
21417 };
21418
21419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_GetTicks",kwnames,&obj0)) goto fail;
21420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21421 if (SWIG_arg_fail(1)) SWIG_fail;
21422 {
21423 PyThreadState* __tstate = wxPyBeginAllowThreads();
21424 result = (time_t)((wxDateTime const *)arg1)->GetTicks();
21425
21426 wxPyEndAllowThreads(__tstate);
21427 if (PyErr_Occurred()) SWIG_fail;
21428 }
21429 {
21430 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21431 }
21432 return resultobj;
21433 fail:
21434 return NULL;
21435 }
21436
21437
21438 static PyObject *_wrap_DateTime_GetYear(PyObject *, PyObject *args, PyObject *kwargs) {
21439 PyObject *resultobj;
21440 wxDateTime *arg1 = (wxDateTime *) 0 ;
21441 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21442 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21443 int result;
21444 bool temp2 = false ;
21445 PyObject * obj0 = 0 ;
21446 PyObject * obj1 = 0 ;
21447 char *kwnames[] = {
21448 (char *) "self",(char *) "tz", NULL
21449 };
21450
21451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetYear",kwnames,&obj0,&obj1)) goto fail;
21452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21453 if (SWIG_arg_fail(1)) SWIG_fail;
21454 if (obj1) {
21455 {
21456 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21457 temp2 = true;
21458 }
21459 }
21460 {
21461 PyThreadState* __tstate = wxPyBeginAllowThreads();
21462 result = (int)((wxDateTime const *)arg1)->GetYear((wxDateTime::TimeZone const &)*arg2);
21463
21464 wxPyEndAllowThreads(__tstate);
21465 if (PyErr_Occurred()) SWIG_fail;
21466 }
21467 {
21468 resultobj = SWIG_From_int((int)(result));
21469 }
21470 {
21471 if (temp2) delete arg2;
21472 }
21473 return resultobj;
21474 fail:
21475 {
21476 if (temp2) delete arg2;
21477 }
21478 return NULL;
21479 }
21480
21481
21482 static PyObject *_wrap_DateTime_GetMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj;
21484 wxDateTime *arg1 = (wxDateTime *) 0 ;
21485 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21486 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21487 wxDateTime::Month result;
21488 bool temp2 = false ;
21489 PyObject * obj0 = 0 ;
21490 PyObject * obj1 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self",(char *) "tz", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMonth",kwnames,&obj0,&obj1)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 if (obj1) {
21499 {
21500 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21501 temp2 = true;
21502 }
21503 }
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 result = (wxDateTime::Month)((wxDateTime const *)arg1)->GetMonth((wxDateTime::TimeZone const &)*arg2);
21507
21508 wxPyEndAllowThreads(__tstate);
21509 if (PyErr_Occurred()) SWIG_fail;
21510 }
21511 resultobj = SWIG_From_int((result));
21512 {
21513 if (temp2) delete arg2;
21514 }
21515 return resultobj;
21516 fail:
21517 {
21518 if (temp2) delete arg2;
21519 }
21520 return NULL;
21521 }
21522
21523
21524 static PyObject *_wrap_DateTime_GetDay(PyObject *, PyObject *args, PyObject *kwargs) {
21525 PyObject *resultobj;
21526 wxDateTime *arg1 = (wxDateTime *) 0 ;
21527 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21528 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21529 int result;
21530 bool temp2 = false ;
21531 PyObject * obj0 = 0 ;
21532 PyObject * obj1 = 0 ;
21533 char *kwnames[] = {
21534 (char *) "self",(char *) "tz", NULL
21535 };
21536
21537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDay",kwnames,&obj0,&obj1)) goto fail;
21538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21539 if (SWIG_arg_fail(1)) SWIG_fail;
21540 if (obj1) {
21541 {
21542 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21543 temp2 = true;
21544 }
21545 }
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (int)((wxDateTime const *)arg1)->GetDay((wxDateTime::TimeZone const &)*arg2);
21549
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 {
21554 resultobj = SWIG_From_int((int)(result));
21555 }
21556 {
21557 if (temp2) delete arg2;
21558 }
21559 return resultobj;
21560 fail:
21561 {
21562 if (temp2) delete arg2;
21563 }
21564 return NULL;
21565 }
21566
21567
21568 static PyObject *_wrap_DateTime_GetWeekDay(PyObject *, PyObject *args, PyObject *kwargs) {
21569 PyObject *resultobj;
21570 wxDateTime *arg1 = (wxDateTime *) 0 ;
21571 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21572 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21573 wxDateTime::WeekDay result;
21574 bool temp2 = false ;
21575 PyObject * obj0 = 0 ;
21576 PyObject * obj1 = 0 ;
21577 char *kwnames[] = {
21578 (char *) "self",(char *) "tz", NULL
21579 };
21580
21581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetWeekDay",kwnames,&obj0,&obj1)) goto fail;
21582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21583 if (SWIG_arg_fail(1)) SWIG_fail;
21584 if (obj1) {
21585 {
21586 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21587 temp2 = true;
21588 }
21589 }
21590 {
21591 PyThreadState* __tstate = wxPyBeginAllowThreads();
21592 result = (wxDateTime::WeekDay)((wxDateTime const *)arg1)->GetWeekDay((wxDateTime::TimeZone const &)*arg2);
21593
21594 wxPyEndAllowThreads(__tstate);
21595 if (PyErr_Occurred()) SWIG_fail;
21596 }
21597 resultobj = SWIG_From_int((result));
21598 {
21599 if (temp2) delete arg2;
21600 }
21601 return resultobj;
21602 fail:
21603 {
21604 if (temp2) delete arg2;
21605 }
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_DateTime_GetHour(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxDateTime *arg1 = (wxDateTime *) 0 ;
21613 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21614 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21615 int result;
21616 bool temp2 = false ;
21617 PyObject * obj0 = 0 ;
21618 PyObject * obj1 = 0 ;
21619 char *kwnames[] = {
21620 (char *) "self",(char *) "tz", NULL
21621 };
21622
21623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetHour",kwnames,&obj0,&obj1)) goto fail;
21624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21625 if (SWIG_arg_fail(1)) SWIG_fail;
21626 if (obj1) {
21627 {
21628 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21629 temp2 = true;
21630 }
21631 }
21632 {
21633 PyThreadState* __tstate = wxPyBeginAllowThreads();
21634 result = (int)((wxDateTime const *)arg1)->GetHour((wxDateTime::TimeZone const &)*arg2);
21635
21636 wxPyEndAllowThreads(__tstate);
21637 if (PyErr_Occurred()) SWIG_fail;
21638 }
21639 {
21640 resultobj = SWIG_From_int((int)(result));
21641 }
21642 {
21643 if (temp2) delete arg2;
21644 }
21645 return resultobj;
21646 fail:
21647 {
21648 if (temp2) delete arg2;
21649 }
21650 return NULL;
21651 }
21652
21653
21654 static PyObject *_wrap_DateTime_GetMinute(PyObject *, PyObject *args, PyObject *kwargs) {
21655 PyObject *resultobj;
21656 wxDateTime *arg1 = (wxDateTime *) 0 ;
21657 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21658 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21659 int result;
21660 bool temp2 = false ;
21661 PyObject * obj0 = 0 ;
21662 PyObject * obj1 = 0 ;
21663 char *kwnames[] = {
21664 (char *) "self",(char *) "tz", NULL
21665 };
21666
21667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMinute",kwnames,&obj0,&obj1)) goto fail;
21668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21669 if (SWIG_arg_fail(1)) SWIG_fail;
21670 if (obj1) {
21671 {
21672 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21673 temp2 = true;
21674 }
21675 }
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = (int)((wxDateTime const *)arg1)->GetMinute((wxDateTime::TimeZone const &)*arg2);
21679
21680 wxPyEndAllowThreads(__tstate);
21681 if (PyErr_Occurred()) SWIG_fail;
21682 }
21683 {
21684 resultobj = SWIG_From_int((int)(result));
21685 }
21686 {
21687 if (temp2) delete arg2;
21688 }
21689 return resultobj;
21690 fail:
21691 {
21692 if (temp2) delete arg2;
21693 }
21694 return NULL;
21695 }
21696
21697
21698 static PyObject *_wrap_DateTime_GetSecond(PyObject *, PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj;
21700 wxDateTime *arg1 = (wxDateTime *) 0 ;
21701 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21702 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21703 int result;
21704 bool temp2 = false ;
21705 PyObject * obj0 = 0 ;
21706 PyObject * obj1 = 0 ;
21707 char *kwnames[] = {
21708 (char *) "self",(char *) "tz", NULL
21709 };
21710
21711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetSecond",kwnames,&obj0,&obj1)) goto fail;
21712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21713 if (SWIG_arg_fail(1)) SWIG_fail;
21714 if (obj1) {
21715 {
21716 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21717 temp2 = true;
21718 }
21719 }
21720 {
21721 PyThreadState* __tstate = wxPyBeginAllowThreads();
21722 result = (int)((wxDateTime const *)arg1)->GetSecond((wxDateTime::TimeZone const &)*arg2);
21723
21724 wxPyEndAllowThreads(__tstate);
21725 if (PyErr_Occurred()) SWIG_fail;
21726 }
21727 {
21728 resultobj = SWIG_From_int((int)(result));
21729 }
21730 {
21731 if (temp2) delete arg2;
21732 }
21733 return resultobj;
21734 fail:
21735 {
21736 if (temp2) delete arg2;
21737 }
21738 return NULL;
21739 }
21740
21741
21742 static PyObject *_wrap_DateTime_GetMillisecond(PyObject *, PyObject *args, PyObject *kwargs) {
21743 PyObject *resultobj;
21744 wxDateTime *arg1 = (wxDateTime *) 0 ;
21745 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21746 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21747 int result;
21748 bool temp2 = false ;
21749 PyObject * obj0 = 0 ;
21750 PyObject * obj1 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "self",(char *) "tz", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetMillisecond",kwnames,&obj0,&obj1)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 if (obj1) {
21759 {
21760 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21761 temp2 = true;
21762 }
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (int)((wxDateTime const *)arg1)->GetMillisecond((wxDateTime::TimeZone const &)*arg2);
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 {
21772 resultobj = SWIG_From_int((int)(result));
21773 }
21774 {
21775 if (temp2) delete arg2;
21776 }
21777 return resultobj;
21778 fail:
21779 {
21780 if (temp2) delete arg2;
21781 }
21782 return NULL;
21783 }
21784
21785
21786 static PyObject *_wrap_DateTime_GetDayOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21787 PyObject *resultobj;
21788 wxDateTime *arg1 = (wxDateTime *) 0 ;
21789 wxDateTime::TimeZone const &arg2_defvalue = LOCAL_TZ ;
21790 wxDateTime::TimeZone *arg2 = (wxDateTime::TimeZone *) &arg2_defvalue ;
21791 int result;
21792 bool temp2 = false ;
21793 PyObject * obj0 = 0 ;
21794 PyObject * obj1 = 0 ;
21795 char *kwnames[] = {
21796 (char *) "self",(char *) "tz", NULL
21797 };
21798
21799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_GetDayOfYear",kwnames,&obj0,&obj1)) goto fail;
21800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21801 if (SWIG_arg_fail(1)) SWIG_fail;
21802 if (obj1) {
21803 {
21804 arg2 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj1));
21805 temp2 = true;
21806 }
21807 }
21808 {
21809 PyThreadState* __tstate = wxPyBeginAllowThreads();
21810 result = (int)((wxDateTime const *)arg1)->GetDayOfYear((wxDateTime::TimeZone const &)*arg2);
21811
21812 wxPyEndAllowThreads(__tstate);
21813 if (PyErr_Occurred()) SWIG_fail;
21814 }
21815 {
21816 resultobj = SWIG_From_int((int)(result));
21817 }
21818 {
21819 if (temp2) delete arg2;
21820 }
21821 return resultobj;
21822 fail:
21823 {
21824 if (temp2) delete arg2;
21825 }
21826 return NULL;
21827 }
21828
21829
21830 static PyObject *_wrap_DateTime_GetWeekOfYear(PyObject *, PyObject *args, PyObject *kwargs) {
21831 PyObject *resultobj;
21832 wxDateTime *arg1 = (wxDateTime *) 0 ;
21833 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21834 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21835 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21836 int result;
21837 bool temp3 = false ;
21838 PyObject * obj0 = 0 ;
21839 PyObject * obj1 = 0 ;
21840 PyObject * obj2 = 0 ;
21841 char *kwnames[] = {
21842 (char *) "self",(char *) "flags",(char *) "tz", NULL
21843 };
21844
21845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfYear",kwnames,&obj0,&obj1,&obj2)) goto fail;
21846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21847 if (SWIG_arg_fail(1)) SWIG_fail;
21848 if (obj1) {
21849 {
21850 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21851 if (SWIG_arg_fail(2)) SWIG_fail;
21852 }
21853 }
21854 if (obj2) {
21855 {
21856 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21857 temp3 = true;
21858 }
21859 }
21860 {
21861 PyThreadState* __tstate = wxPyBeginAllowThreads();
21862 result = (int)((wxDateTime const *)arg1)->GetWeekOfYear((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21863
21864 wxPyEndAllowThreads(__tstate);
21865 if (PyErr_Occurred()) SWIG_fail;
21866 }
21867 {
21868 resultobj = SWIG_From_int((int)(result));
21869 }
21870 {
21871 if (temp3) delete arg3;
21872 }
21873 return resultobj;
21874 fail:
21875 {
21876 if (temp3) delete arg3;
21877 }
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_DateTime_GetWeekOfMonth(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj;
21884 wxDateTime *arg1 = (wxDateTime *) 0 ;
21885 wxDateTime::WeekFlags arg2 = (wxDateTime::WeekFlags) wxDateTime::Monday_First ;
21886 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
21887 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
21888 int result;
21889 bool temp3 = false ;
21890 PyObject * obj0 = 0 ;
21891 PyObject * obj1 = 0 ;
21892 PyObject * obj2 = 0 ;
21893 char *kwnames[] = {
21894 (char *) "self",(char *) "flags",(char *) "tz", NULL
21895 };
21896
21897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_GetWeekOfMonth",kwnames,&obj0,&obj1,&obj2)) goto fail;
21898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21899 if (SWIG_arg_fail(1)) SWIG_fail;
21900 if (obj1) {
21901 {
21902 arg2 = (wxDateTime::WeekFlags)(SWIG_As_int(obj1));
21903 if (SWIG_arg_fail(2)) SWIG_fail;
21904 }
21905 }
21906 if (obj2) {
21907 {
21908 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
21909 temp3 = true;
21910 }
21911 }
21912 {
21913 PyThreadState* __tstate = wxPyBeginAllowThreads();
21914 result = (int)((wxDateTime const *)arg1)->GetWeekOfMonth((wxDateTime::WeekFlags )arg2,(wxDateTime::TimeZone const &)*arg3);
21915
21916 wxPyEndAllowThreads(__tstate);
21917 if (PyErr_Occurred()) SWIG_fail;
21918 }
21919 {
21920 resultobj = SWIG_From_int((int)(result));
21921 }
21922 {
21923 if (temp3) delete arg3;
21924 }
21925 return resultobj;
21926 fail:
21927 {
21928 if (temp3) delete arg3;
21929 }
21930 return NULL;
21931 }
21932
21933
21934 static PyObject *_wrap_DateTime_IsWorkDay(PyObject *, PyObject *args, PyObject *kwargs) {
21935 PyObject *resultobj;
21936 wxDateTime *arg1 = (wxDateTime *) 0 ;
21937 wxDateTime::Country arg2 = (wxDateTime::Country) wxDateTime::Country_Default ;
21938 bool result;
21939 PyObject * obj0 = 0 ;
21940 PyObject * obj1 = 0 ;
21941 char *kwnames[] = {
21942 (char *) "self",(char *) "country", NULL
21943 };
21944
21945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DateTime_IsWorkDay",kwnames,&obj0,&obj1)) goto fail;
21946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21947 if (SWIG_arg_fail(1)) SWIG_fail;
21948 if (obj1) {
21949 {
21950 arg2 = (wxDateTime::Country)(SWIG_As_int(obj1));
21951 if (SWIG_arg_fail(2)) SWIG_fail;
21952 }
21953 }
21954 {
21955 PyThreadState* __tstate = wxPyBeginAllowThreads();
21956 result = (bool)((wxDateTime const *)arg1)->IsWorkDay((wxDateTime::Country )arg2);
21957
21958 wxPyEndAllowThreads(__tstate);
21959 if (PyErr_Occurred()) SWIG_fail;
21960 }
21961 {
21962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21963 }
21964 return resultobj;
21965 fail:
21966 return NULL;
21967 }
21968
21969
21970 static PyObject *_wrap_DateTime_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
21971 PyObject *resultobj;
21972 wxDateTime *arg1 = (wxDateTime *) 0 ;
21973 wxDateTime *arg2 = 0 ;
21974 bool result;
21975 PyObject * obj0 = 0 ;
21976 PyObject * obj1 = 0 ;
21977 char *kwnames[] = {
21978 (char *) "self",(char *) "datetime", NULL
21979 };
21980
21981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
21982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21983 if (SWIG_arg_fail(1)) SWIG_fail;
21984 {
21985 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21986 if (SWIG_arg_fail(2)) SWIG_fail;
21987 if (arg2 == NULL) {
21988 SWIG_null_ref("wxDateTime");
21989 }
21990 if (SWIG_arg_fail(2)) SWIG_fail;
21991 }
21992 {
21993 PyThreadState* __tstate = wxPyBeginAllowThreads();
21994 result = (bool)((wxDateTime const *)arg1)->IsEqualTo((wxDateTime const &)*arg2);
21995
21996 wxPyEndAllowThreads(__tstate);
21997 if (PyErr_Occurred()) SWIG_fail;
21998 }
21999 {
22000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22001 }
22002 return resultobj;
22003 fail:
22004 return NULL;
22005 }
22006
22007
22008 static PyObject *_wrap_DateTime_IsEarlierThan(PyObject *, PyObject *args, PyObject *kwargs) {
22009 PyObject *resultobj;
22010 wxDateTime *arg1 = (wxDateTime *) 0 ;
22011 wxDateTime *arg2 = 0 ;
22012 bool result;
22013 PyObject * obj0 = 0 ;
22014 PyObject * obj1 = 0 ;
22015 char *kwnames[] = {
22016 (char *) "self",(char *) "datetime", NULL
22017 };
22018
22019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsEarlierThan",kwnames,&obj0,&obj1)) goto fail;
22020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22021 if (SWIG_arg_fail(1)) SWIG_fail;
22022 {
22023 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22024 if (SWIG_arg_fail(2)) SWIG_fail;
22025 if (arg2 == NULL) {
22026 SWIG_null_ref("wxDateTime");
22027 }
22028 if (SWIG_arg_fail(2)) SWIG_fail;
22029 }
22030 {
22031 PyThreadState* __tstate = wxPyBeginAllowThreads();
22032 result = (bool)((wxDateTime const *)arg1)->IsEarlierThan((wxDateTime const &)*arg2);
22033
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 static PyObject *_wrap_DateTime_IsLaterThan(PyObject *, PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj;
22048 wxDateTime *arg1 = (wxDateTime *) 0 ;
22049 wxDateTime *arg2 = 0 ;
22050 bool result;
22051 PyObject * obj0 = 0 ;
22052 PyObject * obj1 = 0 ;
22053 char *kwnames[] = {
22054 (char *) "self",(char *) "datetime", NULL
22055 };
22056
22057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsLaterThan",kwnames,&obj0,&obj1)) goto fail;
22058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22059 if (SWIG_arg_fail(1)) SWIG_fail;
22060 {
22061 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22062 if (SWIG_arg_fail(2)) SWIG_fail;
22063 if (arg2 == NULL) {
22064 SWIG_null_ref("wxDateTime");
22065 }
22066 if (SWIG_arg_fail(2)) SWIG_fail;
22067 }
22068 {
22069 PyThreadState* __tstate = wxPyBeginAllowThreads();
22070 result = (bool)((wxDateTime const *)arg1)->IsLaterThan((wxDateTime const &)*arg2);
22071
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 {
22076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22077 }
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 static PyObject *_wrap_DateTime_IsStrictlyBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22085 PyObject *resultobj;
22086 wxDateTime *arg1 = (wxDateTime *) 0 ;
22087 wxDateTime *arg2 = 0 ;
22088 wxDateTime *arg3 = 0 ;
22089 bool result;
22090 PyObject * obj0 = 0 ;
22091 PyObject * obj1 = 0 ;
22092 PyObject * obj2 = 0 ;
22093 char *kwnames[] = {
22094 (char *) "self",(char *) "t1",(char *) "t2", NULL
22095 };
22096
22097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsStrictlyBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22099 if (SWIG_arg_fail(1)) SWIG_fail;
22100 {
22101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22102 if (SWIG_arg_fail(2)) SWIG_fail;
22103 if (arg2 == NULL) {
22104 SWIG_null_ref("wxDateTime");
22105 }
22106 if (SWIG_arg_fail(2)) SWIG_fail;
22107 }
22108 {
22109 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22110 if (SWIG_arg_fail(3)) SWIG_fail;
22111 if (arg3 == NULL) {
22112 SWIG_null_ref("wxDateTime");
22113 }
22114 if (SWIG_arg_fail(3)) SWIG_fail;
22115 }
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (bool)((wxDateTime const *)arg1)->IsStrictlyBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22119
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 {
22124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22125 }
22126 return resultobj;
22127 fail:
22128 return NULL;
22129 }
22130
22131
22132 static PyObject *_wrap_DateTime_IsBetween(PyObject *, PyObject *args, PyObject *kwargs) {
22133 PyObject *resultobj;
22134 wxDateTime *arg1 = (wxDateTime *) 0 ;
22135 wxDateTime *arg2 = 0 ;
22136 wxDateTime *arg3 = 0 ;
22137 bool result;
22138 PyObject * obj0 = 0 ;
22139 PyObject * obj1 = 0 ;
22140 PyObject * obj2 = 0 ;
22141 char *kwnames[] = {
22142 (char *) "self",(char *) "t1",(char *) "t2", NULL
22143 };
22144
22145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsBetween",kwnames,&obj0,&obj1,&obj2)) goto fail;
22146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22147 if (SWIG_arg_fail(1)) SWIG_fail;
22148 {
22149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22150 if (SWIG_arg_fail(2)) SWIG_fail;
22151 if (arg2 == NULL) {
22152 SWIG_null_ref("wxDateTime");
22153 }
22154 if (SWIG_arg_fail(2)) SWIG_fail;
22155 }
22156 {
22157 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22158 if (SWIG_arg_fail(3)) SWIG_fail;
22159 if (arg3 == NULL) {
22160 SWIG_null_ref("wxDateTime");
22161 }
22162 if (SWIG_arg_fail(3)) SWIG_fail;
22163 }
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (bool)((wxDateTime const *)arg1)->IsBetween((wxDateTime const &)*arg2,(wxDateTime const &)*arg3);
22167
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 {
22172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22173 }
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 static PyObject *_wrap_DateTime_IsSameDate(PyObject *, PyObject *args, PyObject *kwargs) {
22181 PyObject *resultobj;
22182 wxDateTime *arg1 = (wxDateTime *) 0 ;
22183 wxDateTime *arg2 = 0 ;
22184 bool result;
22185 PyObject * obj0 = 0 ;
22186 PyObject * obj1 = 0 ;
22187 char *kwnames[] = {
22188 (char *) "self",(char *) "dt", NULL
22189 };
22190
22191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameDate",kwnames,&obj0,&obj1)) goto fail;
22192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22193 if (SWIG_arg_fail(1)) SWIG_fail;
22194 {
22195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22196 if (SWIG_arg_fail(2)) SWIG_fail;
22197 if (arg2 == NULL) {
22198 SWIG_null_ref("wxDateTime");
22199 }
22200 if (SWIG_arg_fail(2)) SWIG_fail;
22201 }
22202 {
22203 PyThreadState* __tstate = wxPyBeginAllowThreads();
22204 result = (bool)((wxDateTime const *)arg1)->IsSameDate((wxDateTime const &)*arg2);
22205
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 {
22210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22211 }
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 static PyObject *_wrap_DateTime_IsSameTime(PyObject *, PyObject *args, PyObject *kwargs) {
22219 PyObject *resultobj;
22220 wxDateTime *arg1 = (wxDateTime *) 0 ;
22221 wxDateTime *arg2 = 0 ;
22222 bool result;
22223 PyObject * obj0 = 0 ;
22224 PyObject * obj1 = 0 ;
22225 char *kwnames[] = {
22226 (char *) "self",(char *) "dt", NULL
22227 };
22228
22229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_IsSameTime",kwnames,&obj0,&obj1)) goto fail;
22230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22231 if (SWIG_arg_fail(1)) SWIG_fail;
22232 {
22233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22234 if (SWIG_arg_fail(2)) SWIG_fail;
22235 if (arg2 == NULL) {
22236 SWIG_null_ref("wxDateTime");
22237 }
22238 if (SWIG_arg_fail(2)) SWIG_fail;
22239 }
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 result = (bool)((wxDateTime const *)arg1)->IsSameTime((wxDateTime const &)*arg2);
22243
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 {
22248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22249 }
22250 return resultobj;
22251 fail:
22252 return NULL;
22253 }
22254
22255
22256 static PyObject *_wrap_DateTime_IsEqualUpTo(PyObject *, PyObject *args, PyObject *kwargs) {
22257 PyObject *resultobj;
22258 wxDateTime *arg1 = (wxDateTime *) 0 ;
22259 wxDateTime *arg2 = 0 ;
22260 wxTimeSpan *arg3 = 0 ;
22261 bool result;
22262 PyObject * obj0 = 0 ;
22263 PyObject * obj1 = 0 ;
22264 PyObject * obj2 = 0 ;
22265 char *kwnames[] = {
22266 (char *) "self",(char *) "dt",(char *) "ts", NULL
22267 };
22268
22269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DateTime_IsEqualUpTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22271 if (SWIG_arg_fail(1)) SWIG_fail;
22272 {
22273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22274 if (SWIG_arg_fail(2)) SWIG_fail;
22275 if (arg2 == NULL) {
22276 SWIG_null_ref("wxDateTime");
22277 }
22278 if (SWIG_arg_fail(2)) SWIG_fail;
22279 }
22280 {
22281 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22282 if (SWIG_arg_fail(3)) SWIG_fail;
22283 if (arg3 == NULL) {
22284 SWIG_null_ref("wxTimeSpan");
22285 }
22286 if (SWIG_arg_fail(3)) SWIG_fail;
22287 }
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 result = (bool)((wxDateTime const *)arg1)->IsEqualUpTo((wxDateTime const &)*arg2,(wxTimeSpan const &)*arg3);
22291
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 {
22296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22297 }
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 static PyObject *_wrap_DateTime_AddTS(PyObject *, PyObject *args, PyObject *kwargs) {
22305 PyObject *resultobj;
22306 wxDateTime *arg1 = (wxDateTime *) 0 ;
22307 wxTimeSpan *arg2 = 0 ;
22308 wxDateTime *result;
22309 PyObject * obj0 = 0 ;
22310 PyObject * obj1 = 0 ;
22311 char *kwnames[] = {
22312 (char *) "self",(char *) "diff", NULL
22313 };
22314
22315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddTS",kwnames,&obj0,&obj1)) goto fail;
22316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22317 if (SWIG_arg_fail(1)) SWIG_fail;
22318 {
22319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22320 if (SWIG_arg_fail(2)) SWIG_fail;
22321 if (arg2 == NULL) {
22322 SWIG_null_ref("wxTimeSpan");
22323 }
22324 if (SWIG_arg_fail(2)) SWIG_fail;
22325 }
22326 {
22327 PyThreadState* __tstate = wxPyBeginAllowThreads();
22328 {
22329 wxDateTime &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
22330 result = (wxDateTime *) &_result_ref;
22331 }
22332
22333 wxPyEndAllowThreads(__tstate);
22334 if (PyErr_Occurred()) SWIG_fail;
22335 }
22336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22337 return resultobj;
22338 fail:
22339 return NULL;
22340 }
22341
22342
22343 static PyObject *_wrap_DateTime_AddDS(PyObject *, PyObject *args, PyObject *kwargs) {
22344 PyObject *resultobj;
22345 wxDateTime *arg1 = (wxDateTime *) 0 ;
22346 wxDateSpan *arg2 = 0 ;
22347 wxDateTime *result;
22348 PyObject * obj0 = 0 ;
22349 PyObject * obj1 = 0 ;
22350 char *kwnames[] = {
22351 (char *) "self",(char *) "diff", NULL
22352 };
22353
22354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_AddDS",kwnames,&obj0,&obj1)) goto fail;
22355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22356 if (SWIG_arg_fail(1)) SWIG_fail;
22357 {
22358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22359 if (SWIG_arg_fail(2)) SWIG_fail;
22360 if (arg2 == NULL) {
22361 SWIG_null_ref("wxDateSpan");
22362 }
22363 if (SWIG_arg_fail(2)) SWIG_fail;
22364 }
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 {
22368 wxDateTime &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
22369 result = (wxDateTime *) &_result_ref;
22370 }
22371
22372 wxPyEndAllowThreads(__tstate);
22373 if (PyErr_Occurred()) SWIG_fail;
22374 }
22375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22376 return resultobj;
22377 fail:
22378 return NULL;
22379 }
22380
22381
22382 static PyObject *_wrap_DateTime_SubtractTS(PyObject *, PyObject *args, PyObject *kwargs) {
22383 PyObject *resultobj;
22384 wxDateTime *arg1 = (wxDateTime *) 0 ;
22385 wxTimeSpan *arg2 = 0 ;
22386 wxDateTime *result;
22387 PyObject * obj0 = 0 ;
22388 PyObject * obj1 = 0 ;
22389 char *kwnames[] = {
22390 (char *) "self",(char *) "diff", NULL
22391 };
22392
22393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractTS",kwnames,&obj0,&obj1)) goto fail;
22394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22395 if (SWIG_arg_fail(1)) SWIG_fail;
22396 {
22397 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22398 if (SWIG_arg_fail(2)) SWIG_fail;
22399 if (arg2 == NULL) {
22400 SWIG_null_ref("wxTimeSpan");
22401 }
22402 if (SWIG_arg_fail(2)) SWIG_fail;
22403 }
22404 {
22405 PyThreadState* __tstate = wxPyBeginAllowThreads();
22406 {
22407 wxDateTime &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
22408 result = (wxDateTime *) &_result_ref;
22409 }
22410
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 static PyObject *_wrap_DateTime_SubtractDS(PyObject *, PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj;
22423 wxDateTime *arg1 = (wxDateTime *) 0 ;
22424 wxDateSpan *arg2 = 0 ;
22425 wxDateTime *result;
22426 PyObject * obj0 = 0 ;
22427 PyObject * obj1 = 0 ;
22428 char *kwnames[] = {
22429 (char *) "self",(char *) "diff", NULL
22430 };
22431
22432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_SubtractDS",kwnames,&obj0,&obj1)) goto fail;
22433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22434 if (SWIG_arg_fail(1)) SWIG_fail;
22435 {
22436 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22437 if (SWIG_arg_fail(2)) SWIG_fail;
22438 if (arg2 == NULL) {
22439 SWIG_null_ref("wxDateSpan");
22440 }
22441 if (SWIG_arg_fail(2)) SWIG_fail;
22442 }
22443 {
22444 PyThreadState* __tstate = wxPyBeginAllowThreads();
22445 {
22446 wxDateTime &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
22447 result = (wxDateTime *) &_result_ref;
22448 }
22449
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 static PyObject *_wrap_DateTime_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj;
22462 wxDateTime *arg1 = (wxDateTime *) 0 ;
22463 wxDateTime *arg2 = 0 ;
22464 wxTimeSpan result;
22465 PyObject * obj0 = 0 ;
22466 PyObject * obj1 = 0 ;
22467 char *kwnames[] = {
22468 (char *) "self",(char *) "dt", NULL
22469 };
22470
22471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_Subtract",kwnames,&obj0,&obj1)) goto fail;
22472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22473 if (SWIG_arg_fail(1)) SWIG_fail;
22474 {
22475 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22476 if (SWIG_arg_fail(2)) SWIG_fail;
22477 if (arg2 == NULL) {
22478 SWIG_null_ref("wxDateTime");
22479 }
22480 if (SWIG_arg_fail(2)) SWIG_fail;
22481 }
22482 {
22483 PyThreadState* __tstate = wxPyBeginAllowThreads();
22484 result = ((wxDateTime const *)arg1)->Subtract((wxDateTime const &)*arg2);
22485
22486 wxPyEndAllowThreads(__tstate);
22487 if (PyErr_Occurred()) SWIG_fail;
22488 }
22489 {
22490 wxTimeSpan * resultptr;
22491 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22493 }
22494 return resultobj;
22495 fail:
22496 return NULL;
22497 }
22498
22499
22500 static PyObject *_wrap_DateTime___iadd____SWIG_0(PyObject *, PyObject *args) {
22501 PyObject *resultobj;
22502 wxDateTime *arg1 = (wxDateTime *) 0 ;
22503 wxTimeSpan *arg2 = 0 ;
22504 wxDateTime *result;
22505 PyObject * obj0 = 0 ;
22506 PyObject * obj1 = 0 ;
22507
22508 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22510 if (SWIG_arg_fail(1)) SWIG_fail;
22511 {
22512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22513 if (SWIG_arg_fail(2)) SWIG_fail;
22514 if (arg2 == NULL) {
22515 SWIG_null_ref("wxTimeSpan");
22516 }
22517 if (SWIG_arg_fail(2)) SWIG_fail;
22518 }
22519 {
22520 PyThreadState* __tstate = wxPyBeginAllowThreads();
22521 {
22522 wxDateTime &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
22523 result = (wxDateTime *) &_result_ref;
22524 }
22525
22526 wxPyEndAllowThreads(__tstate);
22527 if (PyErr_Occurred()) SWIG_fail;
22528 }
22529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 static PyObject *_wrap_DateTime___iadd____SWIG_1(PyObject *, PyObject *args) {
22537 PyObject *resultobj;
22538 wxDateTime *arg1 = (wxDateTime *) 0 ;
22539 wxDateSpan *arg2 = 0 ;
22540 wxDateTime *result;
22541 PyObject * obj0 = 0 ;
22542 PyObject * obj1 = 0 ;
22543
22544 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___iadd__",&obj0,&obj1)) goto fail;
22545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22546 if (SWIG_arg_fail(1)) SWIG_fail;
22547 {
22548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22549 if (SWIG_arg_fail(2)) SWIG_fail;
22550 if (arg2 == NULL) {
22551 SWIG_null_ref("wxDateSpan");
22552 }
22553 if (SWIG_arg_fail(2)) SWIG_fail;
22554 }
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 {
22558 wxDateTime &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
22559 result = (wxDateTime *) &_result_ref;
22560 }
22561
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 static PyObject *_wrap_DateTime___iadd__(PyObject *self, PyObject *args) {
22573 int argc;
22574 PyObject *argv[3];
22575 int ii;
22576
22577 argc = PyObject_Length(args);
22578 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22579 argv[ii] = PyTuple_GetItem(args,ii);
22580 }
22581 if (argc == 2) {
22582 int _v;
22583 {
22584 void *ptr;
22585 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22586 _v = 0;
22587 PyErr_Clear();
22588 } else {
22589 _v = 1;
22590 }
22591 }
22592 if (_v) {
22593 {
22594 void *ptr = 0;
22595 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22596 _v = 0;
22597 PyErr_Clear();
22598 } else {
22599 _v = (ptr != 0);
22600 }
22601 }
22602 if (_v) {
22603 return _wrap_DateTime___iadd____SWIG_0(self,args);
22604 }
22605 }
22606 }
22607 if (argc == 2) {
22608 int _v;
22609 {
22610 void *ptr;
22611 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22612 _v = 0;
22613 PyErr_Clear();
22614 } else {
22615 _v = 1;
22616 }
22617 }
22618 if (_v) {
22619 {
22620 void *ptr = 0;
22621 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22622 _v = 0;
22623 PyErr_Clear();
22624 } else {
22625 _v = (ptr != 0);
22626 }
22627 }
22628 if (_v) {
22629 return _wrap_DateTime___iadd____SWIG_1(self,args);
22630 }
22631 }
22632 }
22633
22634 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___iadd__'");
22635 return NULL;
22636 }
22637
22638
22639 static PyObject *_wrap_DateTime___isub____SWIG_0(PyObject *, PyObject *args) {
22640 PyObject *resultobj;
22641 wxDateTime *arg1 = (wxDateTime *) 0 ;
22642 wxTimeSpan *arg2 = 0 ;
22643 wxDateTime *result;
22644 PyObject * obj0 = 0 ;
22645 PyObject * obj1 = 0 ;
22646
22647 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22649 if (SWIG_arg_fail(1)) SWIG_fail;
22650 {
22651 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22652 if (SWIG_arg_fail(2)) SWIG_fail;
22653 if (arg2 == NULL) {
22654 SWIG_null_ref("wxTimeSpan");
22655 }
22656 if (SWIG_arg_fail(2)) SWIG_fail;
22657 }
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 {
22661 wxDateTime &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
22662 result = (wxDateTime *) &_result_ref;
22663 }
22664
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22669 return resultobj;
22670 fail:
22671 return NULL;
22672 }
22673
22674
22675 static PyObject *_wrap_DateTime___isub____SWIG_1(PyObject *, PyObject *args) {
22676 PyObject *resultobj;
22677 wxDateTime *arg1 = (wxDateTime *) 0 ;
22678 wxDateSpan *arg2 = 0 ;
22679 wxDateTime *result;
22680 PyObject * obj0 = 0 ;
22681 PyObject * obj1 = 0 ;
22682
22683 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___isub__",&obj0,&obj1)) goto fail;
22684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
22685 if (SWIG_arg_fail(1)) SWIG_fail;
22686 {
22687 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22688 if (SWIG_arg_fail(2)) SWIG_fail;
22689 if (arg2 == NULL) {
22690 SWIG_null_ref("wxDateSpan");
22691 }
22692 if (SWIG_arg_fail(2)) SWIG_fail;
22693 }
22694 {
22695 PyThreadState* __tstate = wxPyBeginAllowThreads();
22696 {
22697 wxDateTime &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
22698 result = (wxDateTime *) &_result_ref;
22699 }
22700
22701 wxPyEndAllowThreads(__tstate);
22702 if (PyErr_Occurred()) SWIG_fail;
22703 }
22704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 1);
22705 return resultobj;
22706 fail:
22707 return NULL;
22708 }
22709
22710
22711 static PyObject *_wrap_DateTime___isub__(PyObject *self, PyObject *args) {
22712 int argc;
22713 PyObject *argv[3];
22714 int ii;
22715
22716 argc = PyObject_Length(args);
22717 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22718 argv[ii] = PyTuple_GetItem(args,ii);
22719 }
22720 if (argc == 2) {
22721 int _v;
22722 {
22723 void *ptr;
22724 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22725 _v = 0;
22726 PyErr_Clear();
22727 } else {
22728 _v = 1;
22729 }
22730 }
22731 if (_v) {
22732 {
22733 void *ptr = 0;
22734 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22735 _v = 0;
22736 PyErr_Clear();
22737 } else {
22738 _v = (ptr != 0);
22739 }
22740 }
22741 if (_v) {
22742 return _wrap_DateTime___isub____SWIG_0(self,args);
22743 }
22744 }
22745 }
22746 if (argc == 2) {
22747 int _v;
22748 {
22749 void *ptr;
22750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22751 _v = 0;
22752 PyErr_Clear();
22753 } else {
22754 _v = 1;
22755 }
22756 }
22757 if (_v) {
22758 {
22759 void *ptr = 0;
22760 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22761 _v = 0;
22762 PyErr_Clear();
22763 } else {
22764 _v = (ptr != 0);
22765 }
22766 }
22767 if (_v) {
22768 return _wrap_DateTime___isub____SWIG_1(self,args);
22769 }
22770 }
22771 }
22772
22773 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'DateTime___isub__'");
22774 return NULL;
22775 }
22776
22777
22778 static PyObject *_wrap_DateTime___add____SWIG_0(PyObject *, PyObject *args) {
22779 PyObject *resultobj;
22780 wxDateTime *arg1 = (wxDateTime *) 0 ;
22781 wxTimeSpan *arg2 = 0 ;
22782 wxDateTime result;
22783 PyObject * obj0 = 0 ;
22784 PyObject * obj1 = 0 ;
22785
22786 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22788 if (SWIG_arg_fail(1)) SWIG_fail;
22789 {
22790 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22791 if (SWIG_arg_fail(2)) SWIG_fail;
22792 if (arg2 == NULL) {
22793 SWIG_null_ref("wxTimeSpan");
22794 }
22795 if (SWIG_arg_fail(2)) SWIG_fail;
22796 }
22797 {
22798 PyThreadState* __tstate = wxPyBeginAllowThreads();
22799 result = wxDateTime___add____SWIG_0(arg1,(wxTimeSpan const &)*arg2);
22800
22801 wxPyEndAllowThreads(__tstate);
22802 if (PyErr_Occurred()) SWIG_fail;
22803 }
22804 {
22805 wxDateTime * resultptr;
22806 resultptr = new wxDateTime((wxDateTime &)(result));
22807 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22808 }
22809 return resultobj;
22810 fail:
22811 return NULL;
22812 }
22813
22814
22815 static PyObject *_wrap_DateTime___add____SWIG_1(PyObject *, PyObject *args) {
22816 PyObject *resultobj;
22817 wxDateTime *arg1 = (wxDateTime *) 0 ;
22818 wxDateSpan *arg2 = 0 ;
22819 wxDateTime result;
22820 PyObject * obj0 = 0 ;
22821 PyObject * obj1 = 0 ;
22822
22823 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___add__",&obj0,&obj1)) goto fail;
22824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22825 if (SWIG_arg_fail(1)) SWIG_fail;
22826 {
22827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
22828 if (SWIG_arg_fail(2)) SWIG_fail;
22829 if (arg2 == NULL) {
22830 SWIG_null_ref("wxDateSpan");
22831 }
22832 if (SWIG_arg_fail(2)) SWIG_fail;
22833 }
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = wxDateTime___add____SWIG_1(arg1,(wxDateSpan const &)*arg2);
22837
22838 wxPyEndAllowThreads(__tstate);
22839 if (PyErr_Occurred()) SWIG_fail;
22840 }
22841 {
22842 wxDateTime * resultptr;
22843 resultptr = new wxDateTime((wxDateTime &)(result));
22844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22845 }
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 static PyObject *_wrap_DateTime___add__(PyObject *self, PyObject *args) {
22853 int argc;
22854 PyObject *argv[3];
22855 int ii;
22856
22857 argc = PyObject_Length(args);
22858 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
22859 argv[ii] = PyTuple_GetItem(args,ii);
22860 }
22861 if (argc == 2) {
22862 int _v;
22863 {
22864 void *ptr;
22865 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22866 _v = 0;
22867 PyErr_Clear();
22868 } else {
22869 _v = 1;
22870 }
22871 }
22872 if (_v) {
22873 {
22874 void *ptr = 0;
22875 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
22876 _v = 0;
22877 PyErr_Clear();
22878 } else {
22879 _v = (ptr != 0);
22880 }
22881 }
22882 if (_v) {
22883 return _wrap_DateTime___add____SWIG_0(self,args);
22884 }
22885 }
22886 }
22887 if (argc == 2) {
22888 int _v;
22889 {
22890 void *ptr;
22891 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
22892 _v = 0;
22893 PyErr_Clear();
22894 } else {
22895 _v = 1;
22896 }
22897 }
22898 if (_v) {
22899 {
22900 void *ptr = 0;
22901 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
22902 _v = 0;
22903 PyErr_Clear();
22904 } else {
22905 _v = (ptr != 0);
22906 }
22907 }
22908 if (_v) {
22909 return _wrap_DateTime___add____SWIG_1(self,args);
22910 }
22911 }
22912 }
22913
22914 Py_INCREF(Py_NotImplemented);
22915 return Py_NotImplemented;
22916 }
22917
22918
22919 static PyObject *_wrap_DateTime___sub____SWIG_0(PyObject *, PyObject *args) {
22920 PyObject *resultobj;
22921 wxDateTime *arg1 = (wxDateTime *) 0 ;
22922 wxDateTime *arg2 = 0 ;
22923 wxTimeSpan result;
22924 PyObject * obj0 = 0 ;
22925 PyObject * obj1 = 0 ;
22926
22927 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22929 if (SWIG_arg_fail(1)) SWIG_fail;
22930 {
22931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22932 if (SWIG_arg_fail(2)) SWIG_fail;
22933 if (arg2 == NULL) {
22934 SWIG_null_ref("wxDateTime");
22935 }
22936 if (SWIG_arg_fail(2)) SWIG_fail;
22937 }
22938 {
22939 PyThreadState* __tstate = wxPyBeginAllowThreads();
22940 result = wxDateTime___sub____SWIG_0(arg1,(wxDateTime const &)*arg2);
22941
22942 wxPyEndAllowThreads(__tstate);
22943 if (PyErr_Occurred()) SWIG_fail;
22944 }
22945 {
22946 wxTimeSpan * resultptr;
22947 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
22948 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
22949 }
22950 return resultobj;
22951 fail:
22952 return NULL;
22953 }
22954
22955
22956 static PyObject *_wrap_DateTime___sub____SWIG_1(PyObject *, PyObject *args) {
22957 PyObject *resultobj;
22958 wxDateTime *arg1 = (wxDateTime *) 0 ;
22959 wxTimeSpan *arg2 = 0 ;
22960 wxDateTime result;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963
22964 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
22965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22966 if (SWIG_arg_fail(1)) SWIG_fail;
22967 {
22968 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
22969 if (SWIG_arg_fail(2)) SWIG_fail;
22970 if (arg2 == NULL) {
22971 SWIG_null_ref("wxTimeSpan");
22972 }
22973 if (SWIG_arg_fail(2)) SWIG_fail;
22974 }
22975 {
22976 PyThreadState* __tstate = wxPyBeginAllowThreads();
22977 result = wxDateTime___sub____SWIG_1(arg1,(wxTimeSpan const &)*arg2);
22978
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 wxDateTime * resultptr;
22984 resultptr = new wxDateTime((wxDateTime &)(result));
22985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_DateTime___sub____SWIG_2(PyObject *, PyObject *args) {
22994 PyObject *resultobj;
22995 wxDateTime *arg1 = (wxDateTime *) 0 ;
22996 wxDateSpan *arg2 = 0 ;
22997 wxDateTime result;
22998 PyObject * obj0 = 0 ;
22999 PyObject * obj1 = 0 ;
23000
23001 if(!PyArg_ParseTuple(args,(char *)"OO:DateTime___sub__",&obj0,&obj1)) goto fail;
23002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23003 if (SWIG_arg_fail(1)) SWIG_fail;
23004 {
23005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
23006 if (SWIG_arg_fail(2)) SWIG_fail;
23007 if (arg2 == NULL) {
23008 SWIG_null_ref("wxDateSpan");
23009 }
23010 if (SWIG_arg_fail(2)) SWIG_fail;
23011 }
23012 {
23013 PyThreadState* __tstate = wxPyBeginAllowThreads();
23014 result = wxDateTime___sub____SWIG_2(arg1,(wxDateSpan const &)*arg2);
23015
23016 wxPyEndAllowThreads(__tstate);
23017 if (PyErr_Occurred()) SWIG_fail;
23018 }
23019 {
23020 wxDateTime * resultptr;
23021 resultptr = new wxDateTime((wxDateTime &)(result));
23022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
23023 }
23024 return resultobj;
23025 fail:
23026 return NULL;
23027 }
23028
23029
23030 static PyObject *_wrap_DateTime___sub__(PyObject *self, PyObject *args) {
23031 int argc;
23032 PyObject *argv[3];
23033 int ii;
23034
23035 argc = PyObject_Length(args);
23036 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
23037 argv[ii] = PyTuple_GetItem(args,ii);
23038 }
23039 if (argc == 2) {
23040 int _v;
23041 {
23042 void *ptr;
23043 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23044 _v = 0;
23045 PyErr_Clear();
23046 } else {
23047 _v = 1;
23048 }
23049 }
23050 if (_v) {
23051 {
23052 void *ptr = 0;
23053 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23054 _v = 0;
23055 PyErr_Clear();
23056 } else {
23057 _v = (ptr != 0);
23058 }
23059 }
23060 if (_v) {
23061 return _wrap_DateTime___sub____SWIG_0(self,args);
23062 }
23063 }
23064 }
23065 if (argc == 2) {
23066 int _v;
23067 {
23068 void *ptr;
23069 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23070 _v = 0;
23071 PyErr_Clear();
23072 } else {
23073 _v = 1;
23074 }
23075 }
23076 if (_v) {
23077 {
23078 void *ptr = 0;
23079 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxTimeSpan, 0) == -1) {
23080 _v = 0;
23081 PyErr_Clear();
23082 } else {
23083 _v = (ptr != 0);
23084 }
23085 }
23086 if (_v) {
23087 return _wrap_DateTime___sub____SWIG_1(self,args);
23088 }
23089 }
23090 }
23091 if (argc == 2) {
23092 int _v;
23093 {
23094 void *ptr;
23095 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDateTime, 0) == -1) {
23096 _v = 0;
23097 PyErr_Clear();
23098 } else {
23099 _v = 1;
23100 }
23101 }
23102 if (_v) {
23103 {
23104 void *ptr = 0;
23105 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDateSpan, 0) == -1) {
23106 _v = 0;
23107 PyErr_Clear();
23108 } else {
23109 _v = (ptr != 0);
23110 }
23111 }
23112 if (_v) {
23113 return _wrap_DateTime___sub____SWIG_2(self,args);
23114 }
23115 }
23116 }
23117
23118 Py_INCREF(Py_NotImplemented);
23119 return Py_NotImplemented;
23120 }
23121
23122
23123 static PyObject *_wrap_DateTime___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
23124 PyObject *resultobj;
23125 wxDateTime *arg1 = (wxDateTime *) 0 ;
23126 wxDateTime *arg2 = (wxDateTime *) 0 ;
23127 bool result;
23128 PyObject * obj0 = 0 ;
23129 PyObject * obj1 = 0 ;
23130 char *kwnames[] = {
23131 (char *) "self",(char *) "other", NULL
23132 };
23133
23134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___lt__",kwnames,&obj0,&obj1)) goto fail;
23135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23136 if (SWIG_arg_fail(1)) SWIG_fail;
23137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23138 if (SWIG_arg_fail(2)) SWIG_fail;
23139 {
23140 PyThreadState* __tstate = wxPyBeginAllowThreads();
23141 result = (bool)wxDateTime___lt__(arg1,(wxDateTime const *)arg2);
23142
23143 wxPyEndAllowThreads(__tstate);
23144 if (PyErr_Occurred()) SWIG_fail;
23145 }
23146 {
23147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23148 }
23149 return resultobj;
23150 fail:
23151 return NULL;
23152 }
23153
23154
23155 static PyObject *_wrap_DateTime___le__(PyObject *, PyObject *args, PyObject *kwargs) {
23156 PyObject *resultobj;
23157 wxDateTime *arg1 = (wxDateTime *) 0 ;
23158 wxDateTime *arg2 = (wxDateTime *) 0 ;
23159 bool result;
23160 PyObject * obj0 = 0 ;
23161 PyObject * obj1 = 0 ;
23162 char *kwnames[] = {
23163 (char *) "self",(char *) "other", NULL
23164 };
23165
23166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___le__",kwnames,&obj0,&obj1)) goto fail;
23167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23168 if (SWIG_arg_fail(1)) SWIG_fail;
23169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23170 if (SWIG_arg_fail(2)) SWIG_fail;
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = (bool)wxDateTime___le__(arg1,(wxDateTime const *)arg2);
23174
23175 wxPyEndAllowThreads(__tstate);
23176 if (PyErr_Occurred()) SWIG_fail;
23177 }
23178 {
23179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23180 }
23181 return resultobj;
23182 fail:
23183 return NULL;
23184 }
23185
23186
23187 static PyObject *_wrap_DateTime___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
23188 PyObject *resultobj;
23189 wxDateTime *arg1 = (wxDateTime *) 0 ;
23190 wxDateTime *arg2 = (wxDateTime *) 0 ;
23191 bool result;
23192 PyObject * obj0 = 0 ;
23193 PyObject * obj1 = 0 ;
23194 char *kwnames[] = {
23195 (char *) "self",(char *) "other", NULL
23196 };
23197
23198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___gt__",kwnames,&obj0,&obj1)) goto fail;
23199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23200 if (SWIG_arg_fail(1)) SWIG_fail;
23201 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(2)) SWIG_fail;
23203 {
23204 PyThreadState* __tstate = wxPyBeginAllowThreads();
23205 result = (bool)wxDateTime___gt__(arg1,(wxDateTime const *)arg2);
23206
23207 wxPyEndAllowThreads(__tstate);
23208 if (PyErr_Occurred()) SWIG_fail;
23209 }
23210 {
23211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23212 }
23213 return resultobj;
23214 fail:
23215 return NULL;
23216 }
23217
23218
23219 static PyObject *_wrap_DateTime___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
23220 PyObject *resultobj;
23221 wxDateTime *arg1 = (wxDateTime *) 0 ;
23222 wxDateTime *arg2 = (wxDateTime *) 0 ;
23223 bool result;
23224 PyObject * obj0 = 0 ;
23225 PyObject * obj1 = 0 ;
23226 char *kwnames[] = {
23227 (char *) "self",(char *) "other", NULL
23228 };
23229
23230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ge__",kwnames,&obj0,&obj1)) goto fail;
23231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23232 if (SWIG_arg_fail(1)) SWIG_fail;
23233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(2)) SWIG_fail;
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = (bool)wxDateTime___ge__(arg1,(wxDateTime const *)arg2);
23238
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 {
23243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23244 }
23245 return resultobj;
23246 fail:
23247 return NULL;
23248 }
23249
23250
23251 static PyObject *_wrap_DateTime___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
23252 PyObject *resultobj;
23253 wxDateTime *arg1 = (wxDateTime *) 0 ;
23254 wxDateTime *arg2 = (wxDateTime *) 0 ;
23255 bool result;
23256 PyObject * obj0 = 0 ;
23257 PyObject * obj1 = 0 ;
23258 char *kwnames[] = {
23259 (char *) "self",(char *) "other", NULL
23260 };
23261
23262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___eq__",kwnames,&obj0,&obj1)) goto fail;
23263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23264 if (SWIG_arg_fail(1)) SWIG_fail;
23265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23266 if (SWIG_arg_fail(2)) SWIG_fail;
23267 {
23268 PyThreadState* __tstate = wxPyBeginAllowThreads();
23269 result = (bool)wxDateTime___eq__(arg1,(wxDateTime const *)arg2);
23270
23271 wxPyEndAllowThreads(__tstate);
23272 if (PyErr_Occurred()) SWIG_fail;
23273 }
23274 {
23275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23276 }
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 static PyObject *_wrap_DateTime___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj;
23285 wxDateTime *arg1 = (wxDateTime *) 0 ;
23286 wxDateTime *arg2 = (wxDateTime *) 0 ;
23287 bool result;
23288 PyObject * obj0 = 0 ;
23289 PyObject * obj1 = 0 ;
23290 char *kwnames[] = {
23291 (char *) "self",(char *) "other", NULL
23292 };
23293
23294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime___ne__",kwnames,&obj0,&obj1)) goto fail;
23295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23296 if (SWIG_arg_fail(1)) SWIG_fail;
23297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23298 if (SWIG_arg_fail(2)) SWIG_fail;
23299 {
23300 PyThreadState* __tstate = wxPyBeginAllowThreads();
23301 result = (bool)wxDateTime___ne__(arg1,(wxDateTime const *)arg2);
23302
23303 wxPyEndAllowThreads(__tstate);
23304 if (PyErr_Occurred()) SWIG_fail;
23305 }
23306 {
23307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23308 }
23309 return resultobj;
23310 fail:
23311 return NULL;
23312 }
23313
23314
23315 static PyObject *_wrap_DateTime_ParseRfc822Date(PyObject *, PyObject *args, PyObject *kwargs) {
23316 PyObject *resultobj;
23317 wxDateTime *arg1 = (wxDateTime *) 0 ;
23318 wxString *arg2 = 0 ;
23319 int result;
23320 bool temp2 = false ;
23321 PyObject * obj0 = 0 ;
23322 PyObject * obj1 = 0 ;
23323 char *kwnames[] = {
23324 (char *) "self",(char *) "date", NULL
23325 };
23326
23327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseRfc822Date",kwnames,&obj0,&obj1)) goto fail;
23328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23329 if (SWIG_arg_fail(1)) SWIG_fail;
23330 {
23331 arg2 = wxString_in_helper(obj1);
23332 if (arg2 == NULL) SWIG_fail;
23333 temp2 = true;
23334 }
23335 {
23336 PyThreadState* __tstate = wxPyBeginAllowThreads();
23337 result = (int)wxDateTime_ParseRfc822Date(arg1,(wxString const &)*arg2);
23338
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 {
23343 resultobj = SWIG_From_int((int)(result));
23344 }
23345 {
23346 if (temp2)
23347 delete arg2;
23348 }
23349 return resultobj;
23350 fail:
23351 {
23352 if (temp2)
23353 delete arg2;
23354 }
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_DateTime_ParseFormat(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj;
23361 wxDateTime *arg1 = (wxDateTime *) 0 ;
23362 wxString *arg2 = 0 ;
23363 wxString const &arg3_defvalue = wxPyDefaultDateTimeFormat ;
23364 wxString *arg3 = (wxString *) &arg3_defvalue ;
23365 wxDateTime const &arg4_defvalue = wxDefaultDateTime ;
23366 wxDateTime *arg4 = (wxDateTime *) &arg4_defvalue ;
23367 int result;
23368 bool temp2 = false ;
23369 bool temp3 = false ;
23370 PyObject * obj0 = 0 ;
23371 PyObject * obj1 = 0 ;
23372 PyObject * obj2 = 0 ;
23373 PyObject * obj3 = 0 ;
23374 char *kwnames[] = {
23375 (char *) "self",(char *) "date",(char *) "format",(char *) "dateDef", NULL
23376 };
23377
23378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:DateTime_ParseFormat",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23380 if (SWIG_arg_fail(1)) SWIG_fail;
23381 {
23382 arg2 = wxString_in_helper(obj1);
23383 if (arg2 == NULL) SWIG_fail;
23384 temp2 = true;
23385 }
23386 if (obj2) {
23387 {
23388 arg3 = wxString_in_helper(obj2);
23389 if (arg3 == NULL) SWIG_fail;
23390 temp3 = true;
23391 }
23392 }
23393 if (obj3) {
23394 {
23395 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23396 if (SWIG_arg_fail(4)) SWIG_fail;
23397 if (arg4 == NULL) {
23398 SWIG_null_ref("wxDateTime");
23399 }
23400 if (SWIG_arg_fail(4)) SWIG_fail;
23401 }
23402 }
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = (int)wxDateTime_ParseFormat(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxDateTime const &)*arg4);
23406
23407 wxPyEndAllowThreads(__tstate);
23408 if (PyErr_Occurred()) SWIG_fail;
23409 }
23410 {
23411 resultobj = SWIG_From_int((int)(result));
23412 }
23413 {
23414 if (temp2)
23415 delete arg2;
23416 }
23417 {
23418 if (temp3)
23419 delete arg3;
23420 }
23421 return resultobj;
23422 fail:
23423 {
23424 if (temp2)
23425 delete arg2;
23426 }
23427 {
23428 if (temp3)
23429 delete arg3;
23430 }
23431 return NULL;
23432 }
23433
23434
23435 static PyObject *_wrap_DateTime_ParseDateTime(PyObject *, PyObject *args, PyObject *kwargs) {
23436 PyObject *resultobj;
23437 wxDateTime *arg1 = (wxDateTime *) 0 ;
23438 wxString *arg2 = 0 ;
23439 int result;
23440 bool temp2 = false ;
23441 PyObject * obj0 = 0 ;
23442 PyObject * obj1 = 0 ;
23443 char *kwnames[] = {
23444 (char *) "self",(char *) "datetime", NULL
23445 };
23446
23447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDateTime",kwnames,&obj0,&obj1)) goto fail;
23448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23449 if (SWIG_arg_fail(1)) SWIG_fail;
23450 {
23451 arg2 = wxString_in_helper(obj1);
23452 if (arg2 == NULL) SWIG_fail;
23453 temp2 = true;
23454 }
23455 {
23456 PyThreadState* __tstate = wxPyBeginAllowThreads();
23457 result = (int)wxDateTime_ParseDateTime(arg1,(wxString const &)*arg2);
23458
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 resultobj = SWIG_From_int((int)(result));
23464 }
23465 {
23466 if (temp2)
23467 delete arg2;
23468 }
23469 return resultobj;
23470 fail:
23471 {
23472 if (temp2)
23473 delete arg2;
23474 }
23475 return NULL;
23476 }
23477
23478
23479 static PyObject *_wrap_DateTime_ParseDate(PyObject *, PyObject *args, PyObject *kwargs) {
23480 PyObject *resultobj;
23481 wxDateTime *arg1 = (wxDateTime *) 0 ;
23482 wxString *arg2 = 0 ;
23483 int result;
23484 bool temp2 = false ;
23485 PyObject * obj0 = 0 ;
23486 PyObject * obj1 = 0 ;
23487 char *kwnames[] = {
23488 (char *) "self",(char *) "date", NULL
23489 };
23490
23491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseDate",kwnames,&obj0,&obj1)) goto fail;
23492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23493 if (SWIG_arg_fail(1)) SWIG_fail;
23494 {
23495 arg2 = wxString_in_helper(obj1);
23496 if (arg2 == NULL) SWIG_fail;
23497 temp2 = true;
23498 }
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (int)wxDateTime_ParseDate(arg1,(wxString const &)*arg2);
23502
23503 wxPyEndAllowThreads(__tstate);
23504 if (PyErr_Occurred()) SWIG_fail;
23505 }
23506 {
23507 resultobj = SWIG_From_int((int)(result));
23508 }
23509 {
23510 if (temp2)
23511 delete arg2;
23512 }
23513 return resultobj;
23514 fail:
23515 {
23516 if (temp2)
23517 delete arg2;
23518 }
23519 return NULL;
23520 }
23521
23522
23523 static PyObject *_wrap_DateTime_ParseTime(PyObject *, PyObject *args, PyObject *kwargs) {
23524 PyObject *resultobj;
23525 wxDateTime *arg1 = (wxDateTime *) 0 ;
23526 wxString *arg2 = 0 ;
23527 int result;
23528 bool temp2 = false ;
23529 PyObject * obj0 = 0 ;
23530 PyObject * obj1 = 0 ;
23531 char *kwnames[] = {
23532 (char *) "self",(char *) "time", NULL
23533 };
23534
23535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateTime_ParseTime",kwnames,&obj0,&obj1)) goto fail;
23536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23537 if (SWIG_arg_fail(1)) SWIG_fail;
23538 {
23539 arg2 = wxString_in_helper(obj1);
23540 if (arg2 == NULL) SWIG_fail;
23541 temp2 = true;
23542 }
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 result = (int)wxDateTime_ParseTime(arg1,(wxString const &)*arg2);
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = SWIG_From_int((int)(result));
23552 }
23553 {
23554 if (temp2)
23555 delete arg2;
23556 }
23557 return resultobj;
23558 fail:
23559 {
23560 if (temp2)
23561 delete arg2;
23562 }
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_DateTime_Format(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 wxDateTime *arg1 = (wxDateTime *) 0 ;
23570 wxString const &arg2_defvalue = wxPyDefaultDateTimeFormat ;
23571 wxString *arg2 = (wxString *) &arg2_defvalue ;
23572 wxDateTime::TimeZone const &arg3_defvalue = LOCAL_TZ ;
23573 wxDateTime::TimeZone *arg3 = (wxDateTime::TimeZone *) &arg3_defvalue ;
23574 wxString result;
23575 bool temp2 = false ;
23576 bool temp3 = false ;
23577 PyObject * obj0 = 0 ;
23578 PyObject * obj1 = 0 ;
23579 PyObject * obj2 = 0 ;
23580 char *kwnames[] = {
23581 (char *) "self",(char *) "format",(char *) "tz", NULL
23582 };
23583
23584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:DateTime_Format",kwnames,&obj0,&obj1,&obj2)) goto fail;
23585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23586 if (SWIG_arg_fail(1)) SWIG_fail;
23587 if (obj1) {
23588 {
23589 arg2 = wxString_in_helper(obj1);
23590 if (arg2 == NULL) SWIG_fail;
23591 temp2 = true;
23592 }
23593 }
23594 if (obj2) {
23595 {
23596 arg3 = new wxDateTime::TimeZone((wxDateTime::TZ)PyInt_AsLong(obj2));
23597 temp3 = true;
23598 }
23599 }
23600 {
23601 PyThreadState* __tstate = wxPyBeginAllowThreads();
23602 result = ((wxDateTime const *)arg1)->Format((wxString const &)*arg2,(wxDateTime::TimeZone const &)*arg3);
23603
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 {
23608 #if wxUSE_UNICODE
23609 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23610 #else
23611 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23612 #endif
23613 }
23614 {
23615 if (temp2)
23616 delete arg2;
23617 }
23618 {
23619 if (temp3) delete arg3;
23620 }
23621 return resultobj;
23622 fail:
23623 {
23624 if (temp2)
23625 delete arg2;
23626 }
23627 {
23628 if (temp3) delete arg3;
23629 }
23630 return NULL;
23631 }
23632
23633
23634 static PyObject *_wrap_DateTime_FormatDate(PyObject *, PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj;
23636 wxDateTime *arg1 = (wxDateTime *) 0 ;
23637 wxString result;
23638 PyObject * obj0 = 0 ;
23639 char *kwnames[] = {
23640 (char *) "self", NULL
23641 };
23642
23643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatDate",kwnames,&obj0)) goto fail;
23644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23645 if (SWIG_arg_fail(1)) SWIG_fail;
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = ((wxDateTime const *)arg1)->FormatDate();
23649
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 #if wxUSE_UNICODE
23655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23656 #else
23657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23658 #endif
23659 }
23660 return resultobj;
23661 fail:
23662 return NULL;
23663 }
23664
23665
23666 static PyObject *_wrap_DateTime_FormatTime(PyObject *, PyObject *args, PyObject *kwargs) {
23667 PyObject *resultobj;
23668 wxDateTime *arg1 = (wxDateTime *) 0 ;
23669 wxString result;
23670 PyObject * obj0 = 0 ;
23671 char *kwnames[] = {
23672 (char *) "self", NULL
23673 };
23674
23675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatTime",kwnames,&obj0)) goto fail;
23676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23677 if (SWIG_arg_fail(1)) SWIG_fail;
23678 {
23679 PyThreadState* __tstate = wxPyBeginAllowThreads();
23680 result = ((wxDateTime const *)arg1)->FormatTime();
23681
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 {
23686 #if wxUSE_UNICODE
23687 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23688 #else
23689 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23690 #endif
23691 }
23692 return resultobj;
23693 fail:
23694 return NULL;
23695 }
23696
23697
23698 static PyObject *_wrap_DateTime_FormatISODate(PyObject *, PyObject *args, PyObject *kwargs) {
23699 PyObject *resultobj;
23700 wxDateTime *arg1 = (wxDateTime *) 0 ;
23701 wxString result;
23702 PyObject * obj0 = 0 ;
23703 char *kwnames[] = {
23704 (char *) "self", NULL
23705 };
23706
23707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISODate",kwnames,&obj0)) goto fail;
23708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23709 if (SWIG_arg_fail(1)) SWIG_fail;
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = ((wxDateTime const *)arg1)->FormatISODate();
23713
23714 wxPyEndAllowThreads(__tstate);
23715 if (PyErr_Occurred()) SWIG_fail;
23716 }
23717 {
23718 #if wxUSE_UNICODE
23719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23720 #else
23721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23722 #endif
23723 }
23724 return resultobj;
23725 fail:
23726 return NULL;
23727 }
23728
23729
23730 static PyObject *_wrap_DateTime_FormatISOTime(PyObject *, PyObject *args, PyObject *kwargs) {
23731 PyObject *resultobj;
23732 wxDateTime *arg1 = (wxDateTime *) 0 ;
23733 wxString result;
23734 PyObject * obj0 = 0 ;
23735 char *kwnames[] = {
23736 (char *) "self", NULL
23737 };
23738
23739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateTime_FormatISOTime",kwnames,&obj0)) goto fail;
23740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23741 if (SWIG_arg_fail(1)) SWIG_fail;
23742 {
23743 PyThreadState* __tstate = wxPyBeginAllowThreads();
23744 result = ((wxDateTime const *)arg1)->FormatISOTime();
23745
23746 wxPyEndAllowThreads(__tstate);
23747 if (PyErr_Occurred()) SWIG_fail;
23748 }
23749 {
23750 #if wxUSE_UNICODE
23751 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23752 #else
23753 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23754 #endif
23755 }
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject * DateTime_swigregister(PyObject *, PyObject *args) {
23763 PyObject *obj;
23764 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23765 SWIG_TypeClientData(SWIGTYPE_p_wxDateTime, obj);
23766 Py_INCREF(obj);
23767 return Py_BuildValue((char *)"");
23768 }
23769 static PyObject *_wrap_TimeSpan_Seconds(PyObject *, PyObject *args, PyObject *kwargs) {
23770 PyObject *resultobj;
23771 long arg1 ;
23772 wxTimeSpan result;
23773 PyObject * obj0 = 0 ;
23774 char *kwnames[] = {
23775 (char *) "sec", NULL
23776 };
23777
23778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Seconds",kwnames,&obj0)) goto fail;
23779 {
23780 arg1 = (long)(SWIG_As_long(obj0));
23781 if (SWIG_arg_fail(1)) SWIG_fail;
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = wxTimeSpan::Seconds(arg1);
23786
23787 wxPyEndAllowThreads(__tstate);
23788 if (PyErr_Occurred()) SWIG_fail;
23789 }
23790 {
23791 wxTimeSpan * resultptr;
23792 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23794 }
23795 return resultobj;
23796 fail:
23797 return NULL;
23798 }
23799
23800
23801 static PyObject *_wrap_TimeSpan_Second(PyObject *, PyObject *args, PyObject *kwargs) {
23802 PyObject *resultobj;
23803 wxTimeSpan result;
23804 char *kwnames[] = {
23805 NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Second",kwnames)) goto fail;
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 result = wxTimeSpan::Second();
23812
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 wxTimeSpan * resultptr;
23818 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23819 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23820 }
23821 return resultobj;
23822 fail:
23823 return NULL;
23824 }
23825
23826
23827 static PyObject *_wrap_TimeSpan_Minutes(PyObject *, PyObject *args, PyObject *kwargs) {
23828 PyObject *resultobj;
23829 long arg1 ;
23830 wxTimeSpan result;
23831 PyObject * obj0 = 0 ;
23832 char *kwnames[] = {
23833 (char *) "min", NULL
23834 };
23835
23836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Minutes",kwnames,&obj0)) goto fail;
23837 {
23838 arg1 = (long)(SWIG_As_long(obj0));
23839 if (SWIG_arg_fail(1)) SWIG_fail;
23840 }
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = wxTimeSpan::Minutes(arg1);
23844
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 {
23849 wxTimeSpan * resultptr;
23850 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23851 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23852 }
23853 return resultobj;
23854 fail:
23855 return NULL;
23856 }
23857
23858
23859 static PyObject *_wrap_TimeSpan_Minute(PyObject *, PyObject *args, PyObject *kwargs) {
23860 PyObject *resultobj;
23861 wxTimeSpan result;
23862 char *kwnames[] = {
23863 NULL
23864 };
23865
23866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Minute",kwnames)) goto fail;
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = wxTimeSpan::Minute();
23870
23871 wxPyEndAllowThreads(__tstate);
23872 if (PyErr_Occurred()) SWIG_fail;
23873 }
23874 {
23875 wxTimeSpan * resultptr;
23876 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23878 }
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 static PyObject *_wrap_TimeSpan_Hours(PyObject *, PyObject *args, PyObject *kwargs) {
23886 PyObject *resultobj;
23887 long arg1 ;
23888 wxTimeSpan result;
23889 PyObject * obj0 = 0 ;
23890 char *kwnames[] = {
23891 (char *) "hours", NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Hours",kwnames,&obj0)) goto fail;
23895 {
23896 arg1 = (long)(SWIG_As_long(obj0));
23897 if (SWIG_arg_fail(1)) SWIG_fail;
23898 }
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = wxTimeSpan::Hours(arg1);
23902
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 {
23907 wxTimeSpan * resultptr;
23908 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23909 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23910 }
23911 return resultobj;
23912 fail:
23913 return NULL;
23914 }
23915
23916
23917 static PyObject *_wrap_TimeSpan_Hour(PyObject *, PyObject *args, PyObject *kwargs) {
23918 PyObject *resultobj;
23919 wxTimeSpan result;
23920 char *kwnames[] = {
23921 NULL
23922 };
23923
23924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Hour",kwnames)) goto fail;
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = wxTimeSpan::Hour();
23928
23929 wxPyEndAllowThreads(__tstate);
23930 if (PyErr_Occurred()) SWIG_fail;
23931 }
23932 {
23933 wxTimeSpan * resultptr;
23934 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23936 }
23937 return resultobj;
23938 fail:
23939 return NULL;
23940 }
23941
23942
23943 static PyObject *_wrap_TimeSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
23944 PyObject *resultobj;
23945 long arg1 ;
23946 wxTimeSpan result;
23947 PyObject * obj0 = 0 ;
23948 char *kwnames[] = {
23949 (char *) "days", NULL
23950 };
23951
23952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Days",kwnames,&obj0)) goto fail;
23953 {
23954 arg1 = (long)(SWIG_As_long(obj0));
23955 if (SWIG_arg_fail(1)) SWIG_fail;
23956 }
23957 {
23958 PyThreadState* __tstate = wxPyBeginAllowThreads();
23959 result = wxTimeSpan::Days(arg1);
23960
23961 wxPyEndAllowThreads(__tstate);
23962 if (PyErr_Occurred()) SWIG_fail;
23963 }
23964 {
23965 wxTimeSpan * resultptr;
23966 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23967 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 static PyObject *_wrap_TimeSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
23976 PyObject *resultobj;
23977 wxTimeSpan result;
23978 char *kwnames[] = {
23979 NULL
23980 };
23981
23982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Day",kwnames)) goto fail;
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 result = wxTimeSpan::Day();
23986
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 {
23991 wxTimeSpan * resultptr;
23992 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
23993 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
23994 }
23995 return resultobj;
23996 fail:
23997 return NULL;
23998 }
23999
24000
24001 static PyObject *_wrap_TimeSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
24002 PyObject *resultobj;
24003 long arg1 ;
24004 wxTimeSpan result;
24005 PyObject * obj0 = 0 ;
24006 char *kwnames[] = {
24007 (char *) "days", NULL
24008 };
24009
24010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Weeks",kwnames,&obj0)) goto fail;
24011 {
24012 arg1 = (long)(SWIG_As_long(obj0));
24013 if (SWIG_arg_fail(1)) SWIG_fail;
24014 }
24015 {
24016 PyThreadState* __tstate = wxPyBeginAllowThreads();
24017 result = wxTimeSpan::Weeks(arg1);
24018
24019 wxPyEndAllowThreads(__tstate);
24020 if (PyErr_Occurred()) SWIG_fail;
24021 }
24022 {
24023 wxTimeSpan * resultptr;
24024 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24026 }
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 static PyObject *_wrap_TimeSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj;
24035 wxTimeSpan result;
24036 char *kwnames[] = {
24037 NULL
24038 };
24039
24040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":TimeSpan_Week",kwnames)) goto fail;
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 result = wxTimeSpan::Week();
24044
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 {
24049 wxTimeSpan * resultptr;
24050 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24051 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24052 }
24053 return resultobj;
24054 fail:
24055 return NULL;
24056 }
24057
24058
24059 static PyObject *_wrap_new_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24060 PyObject *resultobj;
24061 long arg1 = (long) 0 ;
24062 long arg2 = (long) 0 ;
24063 long arg3 = (long) 0 ;
24064 long arg4 = (long) 0 ;
24065 wxTimeSpan *result;
24066 PyObject * obj0 = 0 ;
24067 PyObject * obj1 = 0 ;
24068 PyObject * obj2 = 0 ;
24069 PyObject * obj3 = 0 ;
24070 char *kwnames[] = {
24071 (char *) "hours",(char *) "minutes",(char *) "seconds",(char *) "milliseconds", NULL
24072 };
24073
24074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_TimeSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24075 if (obj0) {
24076 {
24077 arg1 = (long)(SWIG_As_long(obj0));
24078 if (SWIG_arg_fail(1)) SWIG_fail;
24079 }
24080 }
24081 if (obj1) {
24082 {
24083 arg2 = (long)(SWIG_As_long(obj1));
24084 if (SWIG_arg_fail(2)) SWIG_fail;
24085 }
24086 }
24087 if (obj2) {
24088 {
24089 arg3 = (long)(SWIG_As_long(obj2));
24090 if (SWIG_arg_fail(3)) SWIG_fail;
24091 }
24092 }
24093 if (obj3) {
24094 {
24095 arg4 = (long)(SWIG_As_long(obj3));
24096 if (SWIG_arg_fail(4)) SWIG_fail;
24097 }
24098 }
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (wxTimeSpan *)new wxTimeSpan(arg1,arg2,arg3,arg4);
24102
24103 wxPyEndAllowThreads(__tstate);
24104 if (PyErr_Occurred()) SWIG_fail;
24105 }
24106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24107 return resultobj;
24108 fail:
24109 return NULL;
24110 }
24111
24112
24113 static PyObject *_wrap_delete_TimeSpan(PyObject *, PyObject *args, PyObject *kwargs) {
24114 PyObject *resultobj;
24115 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24116 PyObject * obj0 = 0 ;
24117 char *kwnames[] = {
24118 (char *) "self", NULL
24119 };
24120
24121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_TimeSpan",kwnames,&obj0)) goto fail;
24122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24123 if (SWIG_arg_fail(1)) SWIG_fail;
24124 {
24125 PyThreadState* __tstate = wxPyBeginAllowThreads();
24126 delete arg1;
24127
24128 wxPyEndAllowThreads(__tstate);
24129 if (PyErr_Occurred()) SWIG_fail;
24130 }
24131 Py_INCREF(Py_None); resultobj = Py_None;
24132 return resultobj;
24133 fail:
24134 return NULL;
24135 }
24136
24137
24138 static PyObject *_wrap_TimeSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
24139 PyObject *resultobj;
24140 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24141 wxTimeSpan *arg2 = 0 ;
24142 wxTimeSpan *result;
24143 PyObject * obj0 = 0 ;
24144 PyObject * obj1 = 0 ;
24145 char *kwnames[] = {
24146 (char *) "self",(char *) "diff", NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Add",kwnames,&obj0,&obj1)) goto fail;
24150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24151 if (SWIG_arg_fail(1)) SWIG_fail;
24152 {
24153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24154 if (SWIG_arg_fail(2)) SWIG_fail;
24155 if (arg2 == NULL) {
24156 SWIG_null_ref("wxTimeSpan");
24157 }
24158 if (SWIG_arg_fail(2)) SWIG_fail;
24159 }
24160 {
24161 PyThreadState* __tstate = wxPyBeginAllowThreads();
24162 {
24163 wxTimeSpan &_result_ref = (arg1)->Add((wxTimeSpan const &)*arg2);
24164 result = (wxTimeSpan *) &_result_ref;
24165 }
24166
24167 wxPyEndAllowThreads(__tstate);
24168 if (PyErr_Occurred()) SWIG_fail;
24169 }
24170 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24171 return resultobj;
24172 fail:
24173 return NULL;
24174 }
24175
24176
24177 static PyObject *_wrap_TimeSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
24178 PyObject *resultobj;
24179 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24180 wxTimeSpan *arg2 = 0 ;
24181 wxTimeSpan *result;
24182 PyObject * obj0 = 0 ;
24183 PyObject * obj1 = 0 ;
24184 char *kwnames[] = {
24185 (char *) "self",(char *) "diff", NULL
24186 };
24187
24188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
24189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24190 if (SWIG_arg_fail(1)) SWIG_fail;
24191 {
24192 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24193 if (SWIG_arg_fail(2)) SWIG_fail;
24194 if (arg2 == NULL) {
24195 SWIG_null_ref("wxTimeSpan");
24196 }
24197 if (SWIG_arg_fail(2)) SWIG_fail;
24198 }
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 {
24202 wxTimeSpan &_result_ref = (arg1)->Subtract((wxTimeSpan const &)*arg2);
24203 result = (wxTimeSpan *) &_result_ref;
24204 }
24205
24206 wxPyEndAllowThreads(__tstate);
24207 if (PyErr_Occurred()) SWIG_fail;
24208 }
24209 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24210 return resultobj;
24211 fail:
24212 return NULL;
24213 }
24214
24215
24216 static PyObject *_wrap_TimeSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
24217 PyObject *resultobj;
24218 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24219 int arg2 ;
24220 wxTimeSpan *result;
24221 PyObject * obj0 = 0 ;
24222 PyObject * obj1 = 0 ;
24223 char *kwnames[] = {
24224 (char *) "self",(char *) "n", NULL
24225 };
24226
24227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
24228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24229 if (SWIG_arg_fail(1)) SWIG_fail;
24230 {
24231 arg2 = (int)(SWIG_As_int(obj1));
24232 if (SWIG_arg_fail(2)) SWIG_fail;
24233 }
24234 {
24235 PyThreadState* __tstate = wxPyBeginAllowThreads();
24236 {
24237 wxTimeSpan &_result_ref = (arg1)->Multiply(arg2);
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_Neg(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_Neg",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 {
24266 wxTimeSpan &_result_ref = (arg1)->Neg();
24267 result = (wxTimeSpan *) &_result_ref;
24268 }
24269
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 static PyObject *_wrap_TimeSpan_Abs(PyObject *, PyObject *args, PyObject *kwargs) {
24281 PyObject *resultobj;
24282 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24283 wxTimeSpan result;
24284 PyObject * obj0 = 0 ;
24285 char *kwnames[] = {
24286 (char *) "self", NULL
24287 };
24288
24289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_Abs",kwnames,&obj0)) goto fail;
24290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24291 if (SWIG_arg_fail(1)) SWIG_fail;
24292 {
24293 PyThreadState* __tstate = wxPyBeginAllowThreads();
24294 result = ((wxTimeSpan const *)arg1)->Abs();
24295
24296 wxPyEndAllowThreads(__tstate);
24297 if (PyErr_Occurred()) SWIG_fail;
24298 }
24299 {
24300 wxTimeSpan * resultptr;
24301 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24303 }
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 static PyObject *_wrap_TimeSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
24311 PyObject *resultobj;
24312 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24313 wxTimeSpan *arg2 = 0 ;
24314 wxTimeSpan *result;
24315 PyObject * obj0 = 0 ;
24316 PyObject * obj1 = 0 ;
24317 char *kwnames[] = {
24318 (char *) "self",(char *) "diff", NULL
24319 };
24320
24321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
24322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24323 if (SWIG_arg_fail(1)) SWIG_fail;
24324 {
24325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24326 if (SWIG_arg_fail(2)) SWIG_fail;
24327 if (arg2 == NULL) {
24328 SWIG_null_ref("wxTimeSpan");
24329 }
24330 if (SWIG_arg_fail(2)) SWIG_fail;
24331 }
24332 {
24333 PyThreadState* __tstate = wxPyBeginAllowThreads();
24334 {
24335 wxTimeSpan &_result_ref = (arg1)->operator +=((wxTimeSpan const &)*arg2);
24336 result = (wxTimeSpan *) &_result_ref;
24337 }
24338
24339 wxPyEndAllowThreads(__tstate);
24340 if (PyErr_Occurred()) SWIG_fail;
24341 }
24342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 static PyObject *_wrap_TimeSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj;
24351 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24352 wxTimeSpan *arg2 = 0 ;
24353 wxTimeSpan *result;
24354 PyObject * obj0 = 0 ;
24355 PyObject * obj1 = 0 ;
24356 char *kwnames[] = {
24357 (char *) "self",(char *) "diff", NULL
24358 };
24359
24360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
24361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24362 if (SWIG_arg_fail(1)) SWIG_fail;
24363 {
24364 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24365 if (SWIG_arg_fail(2)) SWIG_fail;
24366 if (arg2 == NULL) {
24367 SWIG_null_ref("wxTimeSpan");
24368 }
24369 if (SWIG_arg_fail(2)) SWIG_fail;
24370 }
24371 {
24372 PyThreadState* __tstate = wxPyBeginAllowThreads();
24373 {
24374 wxTimeSpan &_result_ref = (arg1)->operator -=((wxTimeSpan const &)*arg2);
24375 result = (wxTimeSpan *) &_result_ref;
24376 }
24377
24378 wxPyEndAllowThreads(__tstate);
24379 if (PyErr_Occurred()) SWIG_fail;
24380 }
24381 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 1);
24382 return resultobj;
24383 fail:
24384 return NULL;
24385 }
24386
24387
24388 static PyObject *_wrap_TimeSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
24389 PyObject *resultobj;
24390 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24391 int arg2 ;
24392 wxTimeSpan *result;
24393 PyObject * obj0 = 0 ;
24394 PyObject * obj1 = 0 ;
24395 char *kwnames[] = {
24396 (char *) "self",(char *) "n", NULL
24397 };
24398
24399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
24400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
24401 if (SWIG_arg_fail(1)) SWIG_fail;
24402 {
24403 arg2 = (int)(SWIG_As_int(obj1));
24404 if (SWIG_arg_fail(2)) SWIG_fail;
24405 }
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 {
24409 wxTimeSpan &_result_ref = (arg1)->operator *=(arg2);
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, 1);
24417 return resultobj;
24418 fail:
24419 return NULL;
24420 }
24421
24422
24423 static PyObject *_wrap_TimeSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
24424 PyObject *resultobj;
24425 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24426 wxTimeSpan *result;
24427 PyObject * obj0 = 0 ;
24428 char *kwnames[] = {
24429 (char *) "self", NULL
24430 };
24431
24432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan___neg__",kwnames,&obj0)) goto fail;
24433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24434 if (SWIG_arg_fail(1)) SWIG_fail;
24435 {
24436 PyThreadState* __tstate = wxPyBeginAllowThreads();
24437 {
24438 wxTimeSpan &_result_ref = (arg1)->operator -();
24439 result = (wxTimeSpan *) &_result_ref;
24440 }
24441
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTimeSpan, 0);
24446 return resultobj;
24447 fail:
24448 return NULL;
24449 }
24450
24451
24452 static PyObject *_wrap_TimeSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
24453 PyObject *resultobj;
24454 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24455 wxTimeSpan *arg2 = 0 ;
24456 wxTimeSpan result;
24457 PyObject * obj0 = 0 ;
24458 PyObject * obj1 = 0 ;
24459 char *kwnames[] = {
24460 (char *) "self",(char *) "other", NULL
24461 };
24462
24463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___add__",kwnames,&obj0,&obj1)) goto fail;
24464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24465 if (SWIG_arg_fail(1)) SWIG_fail;
24466 {
24467 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24468 if (SWIG_arg_fail(2)) SWIG_fail;
24469 if (arg2 == NULL) {
24470 SWIG_null_ref("wxTimeSpan");
24471 }
24472 if (SWIG_arg_fail(2)) SWIG_fail;
24473 }
24474 {
24475 PyThreadState* __tstate = wxPyBeginAllowThreads();
24476 result = wxTimeSpan___add__(arg1,(wxTimeSpan const &)*arg2);
24477
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 {
24482 wxTimeSpan * resultptr;
24483 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24484 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24485 }
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 static PyObject *_wrap_TimeSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj;
24494 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24495 wxTimeSpan *arg2 = 0 ;
24496 wxTimeSpan result;
24497 PyObject * obj0 = 0 ;
24498 PyObject * obj1 = 0 ;
24499 char *kwnames[] = {
24500 (char *) "self",(char *) "other", NULL
24501 };
24502
24503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
24504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24505 if (SWIG_arg_fail(1)) SWIG_fail;
24506 {
24507 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24508 if (SWIG_arg_fail(2)) SWIG_fail;
24509 if (arg2 == NULL) {
24510 SWIG_null_ref("wxTimeSpan");
24511 }
24512 if (SWIG_arg_fail(2)) SWIG_fail;
24513 }
24514 {
24515 PyThreadState* __tstate = wxPyBeginAllowThreads();
24516 result = wxTimeSpan___sub__(arg1,(wxTimeSpan const &)*arg2);
24517
24518 wxPyEndAllowThreads(__tstate);
24519 if (PyErr_Occurred()) SWIG_fail;
24520 }
24521 {
24522 wxTimeSpan * resultptr;
24523 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24525 }
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject *_wrap_TimeSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj;
24534 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24535 int arg2 ;
24536 wxTimeSpan result;
24537 PyObject * obj0 = 0 ;
24538 PyObject * obj1 = 0 ;
24539 char *kwnames[] = {
24540 (char *) "self",(char *) "n", NULL
24541 };
24542
24543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
24544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24545 if (SWIG_arg_fail(1)) SWIG_fail;
24546 {
24547 arg2 = (int)(SWIG_As_int(obj1));
24548 if (SWIG_arg_fail(2)) SWIG_fail;
24549 }
24550 {
24551 PyThreadState* __tstate = wxPyBeginAllowThreads();
24552 result = wxTimeSpan___mul__(arg1,arg2);
24553
24554 wxPyEndAllowThreads(__tstate);
24555 if (PyErr_Occurred()) SWIG_fail;
24556 }
24557 {
24558 wxTimeSpan * resultptr;
24559 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24561 }
24562 return resultobj;
24563 fail:
24564 return NULL;
24565 }
24566
24567
24568 static PyObject *_wrap_TimeSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
24569 PyObject *resultobj;
24570 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24571 int arg2 ;
24572 wxTimeSpan result;
24573 PyObject * obj0 = 0 ;
24574 PyObject * obj1 = 0 ;
24575 char *kwnames[] = {
24576 (char *) "self",(char *) "n", NULL
24577 };
24578
24579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
24580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24581 if (SWIG_arg_fail(1)) SWIG_fail;
24582 {
24583 arg2 = (int)(SWIG_As_int(obj1));
24584 if (SWIG_arg_fail(2)) SWIG_fail;
24585 }
24586 {
24587 PyThreadState* __tstate = wxPyBeginAllowThreads();
24588 result = wxTimeSpan___rmul__(arg1,arg2);
24589
24590 wxPyEndAllowThreads(__tstate);
24591 if (PyErr_Occurred()) SWIG_fail;
24592 }
24593 {
24594 wxTimeSpan * resultptr;
24595 resultptr = new wxTimeSpan((wxTimeSpan &)(result));
24596 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxTimeSpan, 1);
24597 }
24598 return resultobj;
24599 fail:
24600 return NULL;
24601 }
24602
24603
24604 static PyObject *_wrap_TimeSpan___lt__(PyObject *, PyObject *args, PyObject *kwargs) {
24605 PyObject *resultobj;
24606 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24607 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24608 bool result;
24609 PyObject * obj0 = 0 ;
24610 PyObject * obj1 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "self",(char *) "other", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___lt__",kwnames,&obj0,&obj1)) goto fail;
24616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(1)) SWIG_fail;
24618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24619 if (SWIG_arg_fail(2)) SWIG_fail;
24620 {
24621 PyThreadState* __tstate = wxPyBeginAllowThreads();
24622 result = (bool)wxTimeSpan___lt__(arg1,(wxTimeSpan const *)arg2);
24623
24624 wxPyEndAllowThreads(__tstate);
24625 if (PyErr_Occurred()) SWIG_fail;
24626 }
24627 {
24628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24629 }
24630 return resultobj;
24631 fail:
24632 return NULL;
24633 }
24634
24635
24636 static PyObject *_wrap_TimeSpan___le__(PyObject *, PyObject *args, PyObject *kwargs) {
24637 PyObject *resultobj;
24638 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24639 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24640 bool result;
24641 PyObject * obj0 = 0 ;
24642 PyObject * obj1 = 0 ;
24643 char *kwnames[] = {
24644 (char *) "self",(char *) "other", NULL
24645 };
24646
24647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___le__",kwnames,&obj0,&obj1)) goto fail;
24648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24649 if (SWIG_arg_fail(1)) SWIG_fail;
24650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24651 if (SWIG_arg_fail(2)) SWIG_fail;
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (bool)wxTimeSpan___le__(arg1,(wxTimeSpan const *)arg2);
24655
24656 wxPyEndAllowThreads(__tstate);
24657 if (PyErr_Occurred()) SWIG_fail;
24658 }
24659 {
24660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24661 }
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 static PyObject *_wrap_TimeSpan___gt__(PyObject *, PyObject *args, PyObject *kwargs) {
24669 PyObject *resultobj;
24670 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24671 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24672 bool result;
24673 PyObject * obj0 = 0 ;
24674 PyObject * obj1 = 0 ;
24675 char *kwnames[] = {
24676 (char *) "self",(char *) "other", NULL
24677 };
24678
24679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___gt__",kwnames,&obj0,&obj1)) goto fail;
24680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24681 if (SWIG_arg_fail(1)) SWIG_fail;
24682 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24683 if (SWIG_arg_fail(2)) SWIG_fail;
24684 {
24685 PyThreadState* __tstate = wxPyBeginAllowThreads();
24686 result = (bool)wxTimeSpan___gt__(arg1,(wxTimeSpan const *)arg2);
24687
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 {
24692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24693 }
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_TimeSpan___ge__(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj;
24702 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24703 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24704 bool result;
24705 PyObject * obj0 = 0 ;
24706 PyObject * obj1 = 0 ;
24707 char *kwnames[] = {
24708 (char *) "self",(char *) "other", NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ge__",kwnames,&obj0,&obj1)) goto fail;
24712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24713 if (SWIG_arg_fail(1)) SWIG_fail;
24714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24715 if (SWIG_arg_fail(2)) SWIG_fail;
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (bool)wxTimeSpan___ge__(arg1,(wxTimeSpan const *)arg2);
24719
24720 wxPyEndAllowThreads(__tstate);
24721 if (PyErr_Occurred()) SWIG_fail;
24722 }
24723 {
24724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24725 }
24726 return resultobj;
24727 fail:
24728 return NULL;
24729 }
24730
24731
24732 static PyObject *_wrap_TimeSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
24733 PyObject *resultobj;
24734 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24735 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24736 bool result;
24737 PyObject * obj0 = 0 ;
24738 PyObject * obj1 = 0 ;
24739 char *kwnames[] = {
24740 (char *) "self",(char *) "other", NULL
24741 };
24742
24743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
24744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(1)) SWIG_fail;
24746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24747 if (SWIG_arg_fail(2)) SWIG_fail;
24748 {
24749 PyThreadState* __tstate = wxPyBeginAllowThreads();
24750 result = (bool)wxTimeSpan___eq__(arg1,(wxTimeSpan const *)arg2);
24751
24752 wxPyEndAllowThreads(__tstate);
24753 if (PyErr_Occurred()) SWIG_fail;
24754 }
24755 {
24756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24757 }
24758 return resultobj;
24759 fail:
24760 return NULL;
24761 }
24762
24763
24764 static PyObject *_wrap_TimeSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
24765 PyObject *resultobj;
24766 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24767 wxTimeSpan *arg2 = (wxTimeSpan *) 0 ;
24768 bool result;
24769 PyObject * obj0 = 0 ;
24770 PyObject * obj1 = 0 ;
24771 char *kwnames[] = {
24772 (char *) "self",(char *) "other", NULL
24773 };
24774
24775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
24776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24777 if (SWIG_arg_fail(1)) SWIG_fail;
24778 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24779 if (SWIG_arg_fail(2)) SWIG_fail;
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 result = (bool)wxTimeSpan___ne__(arg1,(wxTimeSpan const *)arg2);
24783
24784 wxPyEndAllowThreads(__tstate);
24785 if (PyErr_Occurred()) SWIG_fail;
24786 }
24787 {
24788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24789 }
24790 return resultobj;
24791 fail:
24792 return NULL;
24793 }
24794
24795
24796 static PyObject *_wrap_TimeSpan_IsNull(PyObject *, PyObject *args, PyObject *kwargs) {
24797 PyObject *resultobj;
24798 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24799 bool result;
24800 PyObject * obj0 = 0 ;
24801 char *kwnames[] = {
24802 (char *) "self", NULL
24803 };
24804
24805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNull",kwnames,&obj0)) goto fail;
24806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24807 if (SWIG_arg_fail(1)) SWIG_fail;
24808 {
24809 PyThreadState* __tstate = wxPyBeginAllowThreads();
24810 result = (bool)((wxTimeSpan const *)arg1)->IsNull();
24811
24812 wxPyEndAllowThreads(__tstate);
24813 if (PyErr_Occurred()) SWIG_fail;
24814 }
24815 {
24816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24817 }
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 static PyObject *_wrap_TimeSpan_IsPositive(PyObject *, PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj;
24826 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24827 bool result;
24828 PyObject * obj0 = 0 ;
24829 char *kwnames[] = {
24830 (char *) "self", NULL
24831 };
24832
24833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsPositive",kwnames,&obj0)) goto fail;
24834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24835 if (SWIG_arg_fail(1)) SWIG_fail;
24836 {
24837 PyThreadState* __tstate = wxPyBeginAllowThreads();
24838 result = (bool)((wxTimeSpan const *)arg1)->IsPositive();
24839
24840 wxPyEndAllowThreads(__tstate);
24841 if (PyErr_Occurred()) SWIG_fail;
24842 }
24843 {
24844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24845 }
24846 return resultobj;
24847 fail:
24848 return NULL;
24849 }
24850
24851
24852 static PyObject *_wrap_TimeSpan_IsNegative(PyObject *, PyObject *args, PyObject *kwargs) {
24853 PyObject *resultobj;
24854 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24855 bool result;
24856 PyObject * obj0 = 0 ;
24857 char *kwnames[] = {
24858 (char *) "self", NULL
24859 };
24860
24861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_IsNegative",kwnames,&obj0)) goto fail;
24862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24863 if (SWIG_arg_fail(1)) SWIG_fail;
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)((wxTimeSpan const *)arg1)->IsNegative();
24867
24868 wxPyEndAllowThreads(__tstate);
24869 if (PyErr_Occurred()) SWIG_fail;
24870 }
24871 {
24872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24873 }
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_TimeSpan_IsEqualTo(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj;
24882 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24883 wxTimeSpan *arg2 = 0 ;
24884 bool result;
24885 PyObject * obj0 = 0 ;
24886 PyObject * obj1 = 0 ;
24887 char *kwnames[] = {
24888 (char *) "self",(char *) "ts", NULL
24889 };
24890
24891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsEqualTo",kwnames,&obj0,&obj1)) goto fail;
24892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24893 if (SWIG_arg_fail(1)) SWIG_fail;
24894 {
24895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24896 if (SWIG_arg_fail(2)) SWIG_fail;
24897 if (arg2 == NULL) {
24898 SWIG_null_ref("wxTimeSpan");
24899 }
24900 if (SWIG_arg_fail(2)) SWIG_fail;
24901 }
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (bool)((wxTimeSpan const *)arg1)->IsEqualTo((wxTimeSpan const &)*arg2);
24905
24906 wxPyEndAllowThreads(__tstate);
24907 if (PyErr_Occurred()) SWIG_fail;
24908 }
24909 {
24910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24911 }
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 static PyObject *_wrap_TimeSpan_IsLongerThan(PyObject *, PyObject *args, PyObject *kwargs) {
24919 PyObject *resultobj;
24920 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24921 wxTimeSpan *arg2 = 0 ;
24922 bool result;
24923 PyObject * obj0 = 0 ;
24924 PyObject * obj1 = 0 ;
24925 char *kwnames[] = {
24926 (char *) "self",(char *) "ts", NULL
24927 };
24928
24929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsLongerThan",kwnames,&obj0,&obj1)) goto fail;
24930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24931 if (SWIG_arg_fail(1)) SWIG_fail;
24932 {
24933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(2)) SWIG_fail;
24935 if (arg2 == NULL) {
24936 SWIG_null_ref("wxTimeSpan");
24937 }
24938 if (SWIG_arg_fail(2)) SWIG_fail;
24939 }
24940 {
24941 PyThreadState* __tstate = wxPyBeginAllowThreads();
24942 result = (bool)((wxTimeSpan const *)arg1)->IsLongerThan((wxTimeSpan const &)*arg2);
24943
24944 wxPyEndAllowThreads(__tstate);
24945 if (PyErr_Occurred()) SWIG_fail;
24946 }
24947 {
24948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24949 }
24950 return resultobj;
24951 fail:
24952 return NULL;
24953 }
24954
24955
24956 static PyObject *_wrap_TimeSpan_IsShorterThan(PyObject *, PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj;
24958 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24959 wxTimeSpan *arg2 = 0 ;
24960 bool result;
24961 PyObject * obj0 = 0 ;
24962 PyObject * obj1 = 0 ;
24963 char *kwnames[] = {
24964 (char *) "self",(char *) "t", NULL
24965 };
24966
24967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TimeSpan_IsShorterThan",kwnames,&obj0,&obj1)) goto fail;
24968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24969 if (SWIG_arg_fail(1)) SWIG_fail;
24970 {
24971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
24972 if (SWIG_arg_fail(2)) SWIG_fail;
24973 if (arg2 == NULL) {
24974 SWIG_null_ref("wxTimeSpan");
24975 }
24976 if (SWIG_arg_fail(2)) SWIG_fail;
24977 }
24978 {
24979 PyThreadState* __tstate = wxPyBeginAllowThreads();
24980 result = (bool)((wxTimeSpan const *)arg1)->IsShorterThan((wxTimeSpan const &)*arg2);
24981
24982 wxPyEndAllowThreads(__tstate);
24983 if (PyErr_Occurred()) SWIG_fail;
24984 }
24985 {
24986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24987 }
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 static PyObject *_wrap_TimeSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
24995 PyObject *resultobj;
24996 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
24997 int result;
24998 PyObject * obj0 = 0 ;
24999 char *kwnames[] = {
25000 (char *) "self", NULL
25001 };
25002
25003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetWeeks",kwnames,&obj0)) goto fail;
25004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25005 if (SWIG_arg_fail(1)) SWIG_fail;
25006 {
25007 PyThreadState* __tstate = wxPyBeginAllowThreads();
25008 result = (int)((wxTimeSpan const *)arg1)->GetWeeks();
25009
25010 wxPyEndAllowThreads(__tstate);
25011 if (PyErr_Occurred()) SWIG_fail;
25012 }
25013 {
25014 resultobj = SWIG_From_int((int)(result));
25015 }
25016 return resultobj;
25017 fail:
25018 return NULL;
25019 }
25020
25021
25022 static PyObject *_wrap_TimeSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25023 PyObject *resultobj;
25024 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25025 int result;
25026 PyObject * obj0 = 0 ;
25027 char *kwnames[] = {
25028 (char *) "self", NULL
25029 };
25030
25031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetDays",kwnames,&obj0)) goto fail;
25032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25033 if (SWIG_arg_fail(1)) SWIG_fail;
25034 {
25035 PyThreadState* __tstate = wxPyBeginAllowThreads();
25036 result = (int)((wxTimeSpan const *)arg1)->GetDays();
25037
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 resultobj = SWIG_From_int((int)(result));
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 static PyObject *_wrap_TimeSpan_GetHours(PyObject *, PyObject *args, PyObject *kwargs) {
25051 PyObject *resultobj;
25052 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25053 int result;
25054 PyObject * obj0 = 0 ;
25055 char *kwnames[] = {
25056 (char *) "self", NULL
25057 };
25058
25059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetHours",kwnames,&obj0)) goto fail;
25060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25061 if (SWIG_arg_fail(1)) SWIG_fail;
25062 {
25063 PyThreadState* __tstate = wxPyBeginAllowThreads();
25064 result = (int)((wxTimeSpan const *)arg1)->GetHours();
25065
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = SWIG_From_int((int)(result));
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 static PyObject *_wrap_TimeSpan_GetMinutes(PyObject *, PyObject *args, PyObject *kwargs) {
25079 PyObject *resultobj;
25080 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25081 int result;
25082 PyObject * obj0 = 0 ;
25083 char *kwnames[] = {
25084 (char *) "self", NULL
25085 };
25086
25087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMinutes",kwnames,&obj0)) goto fail;
25088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25089 if (SWIG_arg_fail(1)) SWIG_fail;
25090 {
25091 PyThreadState* __tstate = wxPyBeginAllowThreads();
25092 result = (int)((wxTimeSpan const *)arg1)->GetMinutes();
25093
25094 wxPyEndAllowThreads(__tstate);
25095 if (PyErr_Occurred()) SWIG_fail;
25096 }
25097 {
25098 resultobj = SWIG_From_int((int)(result));
25099 }
25100 return resultobj;
25101 fail:
25102 return NULL;
25103 }
25104
25105
25106 static PyObject *_wrap_TimeSpan_GetSeconds(PyObject *, PyObject *args, PyObject *kwargs) {
25107 PyObject *resultobj;
25108 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25109 wxLongLong result;
25110 PyObject * obj0 = 0 ;
25111 char *kwnames[] = {
25112 (char *) "self", NULL
25113 };
25114
25115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetSeconds",kwnames,&obj0)) goto fail;
25116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25117 if (SWIG_arg_fail(1)) SWIG_fail;
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = ((wxTimeSpan const *)arg1)->GetSeconds();
25121
25122 wxPyEndAllowThreads(__tstate);
25123 if (PyErr_Occurred()) SWIG_fail;
25124 }
25125 {
25126 PyObject *hi, *lo, *shifter, *shifted;
25127 hi = PyLong_FromLong( (&result)->GetHi() );
25128 lo = PyLong_FromLong( (&result)->GetLo() );
25129 shifter = PyLong_FromLong(32);
25130 shifted = PyNumber_Lshift(hi, shifter);
25131 resultobj = PyNumber_Or(shifted, lo);
25132 Py_DECREF(hi);
25133 Py_DECREF(lo);
25134 Py_DECREF(shifter);
25135 Py_DECREF(shifted);
25136 }
25137 return resultobj;
25138 fail:
25139 return NULL;
25140 }
25141
25142
25143 static PyObject *_wrap_TimeSpan_GetMilliseconds(PyObject *, PyObject *args, PyObject *kwargs) {
25144 PyObject *resultobj;
25145 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25146 wxLongLong result;
25147 PyObject * obj0 = 0 ;
25148 char *kwnames[] = {
25149 (char *) "self", NULL
25150 };
25151
25152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TimeSpan_GetMilliseconds",kwnames,&obj0)) goto fail;
25153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25154 if (SWIG_arg_fail(1)) SWIG_fail;
25155 {
25156 PyThreadState* __tstate = wxPyBeginAllowThreads();
25157 result = ((wxTimeSpan const *)arg1)->GetMilliseconds();
25158
25159 wxPyEndAllowThreads(__tstate);
25160 if (PyErr_Occurred()) SWIG_fail;
25161 }
25162 {
25163 PyObject *hi, *lo, *shifter, *shifted;
25164 hi = PyLong_FromLong( (&result)->GetHi() );
25165 lo = PyLong_FromLong( (&result)->GetLo() );
25166 shifter = PyLong_FromLong(32);
25167 shifted = PyNumber_Lshift(hi, shifter);
25168 resultobj = PyNumber_Or(shifted, lo);
25169 Py_DECREF(hi);
25170 Py_DECREF(lo);
25171 Py_DECREF(shifter);
25172 Py_DECREF(shifted);
25173 }
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 static PyObject *_wrap_TimeSpan_Format(PyObject *, PyObject *args, PyObject *kwargs) {
25181 PyObject *resultobj;
25182 wxTimeSpan *arg1 = (wxTimeSpan *) 0 ;
25183 wxString const &arg2_defvalue = wxPyDefaultTimeSpanFormat ;
25184 wxString *arg2 = (wxString *) &arg2_defvalue ;
25185 wxString result;
25186 bool temp2 = false ;
25187 PyObject * obj0 = 0 ;
25188 PyObject * obj1 = 0 ;
25189 char *kwnames[] = {
25190 (char *) "self",(char *) "format", NULL
25191 };
25192
25193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TimeSpan_Format",kwnames,&obj0,&obj1)) goto fail;
25194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTimeSpan, SWIG_POINTER_EXCEPTION | 0);
25195 if (SWIG_arg_fail(1)) SWIG_fail;
25196 if (obj1) {
25197 {
25198 arg2 = wxString_in_helper(obj1);
25199 if (arg2 == NULL) SWIG_fail;
25200 temp2 = true;
25201 }
25202 }
25203 {
25204 PyThreadState* __tstate = wxPyBeginAllowThreads();
25205 result = ((wxTimeSpan const *)arg1)->Format((wxString const &)*arg2);
25206
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 {
25211 #if wxUSE_UNICODE
25212 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25213 #else
25214 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25215 #endif
25216 }
25217 {
25218 if (temp2)
25219 delete arg2;
25220 }
25221 return resultobj;
25222 fail:
25223 {
25224 if (temp2)
25225 delete arg2;
25226 }
25227 return NULL;
25228 }
25229
25230
25231 static PyObject * TimeSpan_swigregister(PyObject *, PyObject *args) {
25232 PyObject *obj;
25233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25234 SWIG_TypeClientData(SWIGTYPE_p_wxTimeSpan, obj);
25235 Py_INCREF(obj);
25236 return Py_BuildValue((char *)"");
25237 }
25238 static PyObject *_wrap_new_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25239 PyObject *resultobj;
25240 int arg1 = (int) 0 ;
25241 int arg2 = (int) 0 ;
25242 int arg3 = (int) 0 ;
25243 int arg4 = (int) 0 ;
25244 wxDateSpan *result;
25245 PyObject * obj0 = 0 ;
25246 PyObject * obj1 = 0 ;
25247 PyObject * obj2 = 0 ;
25248 PyObject * obj3 = 0 ;
25249 char *kwnames[] = {
25250 (char *) "years",(char *) "months",(char *) "weeks",(char *) "days", NULL
25251 };
25252
25253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_DateSpan",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25254 if (obj0) {
25255 {
25256 arg1 = (int)(SWIG_As_int(obj0));
25257 if (SWIG_arg_fail(1)) SWIG_fail;
25258 }
25259 }
25260 if (obj1) {
25261 {
25262 arg2 = (int)(SWIG_As_int(obj1));
25263 if (SWIG_arg_fail(2)) SWIG_fail;
25264 }
25265 }
25266 if (obj2) {
25267 {
25268 arg3 = (int)(SWIG_As_int(obj2));
25269 if (SWIG_arg_fail(3)) SWIG_fail;
25270 }
25271 }
25272 if (obj3) {
25273 {
25274 arg4 = (int)(SWIG_As_int(obj3));
25275 if (SWIG_arg_fail(4)) SWIG_fail;
25276 }
25277 }
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (wxDateSpan *)new wxDateSpan(arg1,arg2,arg3,arg4);
25281
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 static PyObject *_wrap_delete_DateSpan(PyObject *, PyObject *args, PyObject *kwargs) {
25293 PyObject *resultobj;
25294 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25295 PyObject * obj0 = 0 ;
25296 char *kwnames[] = {
25297 (char *) "self", NULL
25298 };
25299
25300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DateSpan",kwnames,&obj0)) goto fail;
25301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25302 if (SWIG_arg_fail(1)) SWIG_fail;
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 delete arg1;
25306
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 Py_INCREF(Py_None); resultobj = Py_None;
25311 return resultobj;
25312 fail:
25313 return NULL;
25314 }
25315
25316
25317 static PyObject *_wrap_DateSpan_Days(PyObject *, PyObject *args, PyObject *kwargs) {
25318 PyObject *resultobj;
25319 int arg1 ;
25320 wxDateSpan result;
25321 PyObject * obj0 = 0 ;
25322 char *kwnames[] = {
25323 (char *) "days", NULL
25324 };
25325
25326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Days",kwnames,&obj0)) goto fail;
25327 {
25328 arg1 = (int)(SWIG_As_int(obj0));
25329 if (SWIG_arg_fail(1)) SWIG_fail;
25330 }
25331 {
25332 PyThreadState* __tstate = wxPyBeginAllowThreads();
25333 result = wxDateSpan::Days(arg1);
25334
25335 wxPyEndAllowThreads(__tstate);
25336 if (PyErr_Occurred()) SWIG_fail;
25337 }
25338 {
25339 wxDateSpan * resultptr;
25340 resultptr = new wxDateSpan((wxDateSpan &)(result));
25341 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25342 }
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 static PyObject *_wrap_DateSpan_Day(PyObject *, PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj;
25351 wxDateSpan result;
25352 char *kwnames[] = {
25353 NULL
25354 };
25355
25356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Day",kwnames)) goto fail;
25357 {
25358 PyThreadState* __tstate = wxPyBeginAllowThreads();
25359 result = wxDateSpan::Day();
25360
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 {
25365 wxDateSpan * resultptr;
25366 resultptr = new wxDateSpan((wxDateSpan &)(result));
25367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25368 }
25369 return resultobj;
25370 fail:
25371 return NULL;
25372 }
25373
25374
25375 static PyObject *_wrap_DateSpan_Weeks(PyObject *, PyObject *args, PyObject *kwargs) {
25376 PyObject *resultobj;
25377 int arg1 ;
25378 wxDateSpan result;
25379 PyObject * obj0 = 0 ;
25380 char *kwnames[] = {
25381 (char *) "weeks", NULL
25382 };
25383
25384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Weeks",kwnames,&obj0)) goto fail;
25385 {
25386 arg1 = (int)(SWIG_As_int(obj0));
25387 if (SWIG_arg_fail(1)) SWIG_fail;
25388 }
25389 {
25390 PyThreadState* __tstate = wxPyBeginAllowThreads();
25391 result = wxDateSpan::Weeks(arg1);
25392
25393 wxPyEndAllowThreads(__tstate);
25394 if (PyErr_Occurred()) SWIG_fail;
25395 }
25396 {
25397 wxDateSpan * resultptr;
25398 resultptr = new wxDateSpan((wxDateSpan &)(result));
25399 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25400 }
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 static PyObject *_wrap_DateSpan_Week(PyObject *, PyObject *args, PyObject *kwargs) {
25408 PyObject *resultobj;
25409 wxDateSpan result;
25410 char *kwnames[] = {
25411 NULL
25412 };
25413
25414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Week",kwnames)) goto fail;
25415 {
25416 PyThreadState* __tstate = wxPyBeginAllowThreads();
25417 result = wxDateSpan::Week();
25418
25419 wxPyEndAllowThreads(__tstate);
25420 if (PyErr_Occurred()) SWIG_fail;
25421 }
25422 {
25423 wxDateSpan * resultptr;
25424 resultptr = new wxDateSpan((wxDateSpan &)(result));
25425 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25426 }
25427 return resultobj;
25428 fail:
25429 return NULL;
25430 }
25431
25432
25433 static PyObject *_wrap_DateSpan_Months(PyObject *, PyObject *args, PyObject *kwargs) {
25434 PyObject *resultobj;
25435 int arg1 ;
25436 wxDateSpan result;
25437 PyObject * obj0 = 0 ;
25438 char *kwnames[] = {
25439 (char *) "mon", NULL
25440 };
25441
25442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Months",kwnames,&obj0)) goto fail;
25443 {
25444 arg1 = (int)(SWIG_As_int(obj0));
25445 if (SWIG_arg_fail(1)) SWIG_fail;
25446 }
25447 {
25448 PyThreadState* __tstate = wxPyBeginAllowThreads();
25449 result = wxDateSpan::Months(arg1);
25450
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 {
25455 wxDateSpan * resultptr;
25456 resultptr = new wxDateSpan((wxDateSpan &)(result));
25457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25458 }
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 static PyObject *_wrap_DateSpan_Month(PyObject *, PyObject *args, PyObject *kwargs) {
25466 PyObject *resultobj;
25467 wxDateSpan result;
25468 char *kwnames[] = {
25469 NULL
25470 };
25471
25472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Month",kwnames)) goto fail;
25473 {
25474 PyThreadState* __tstate = wxPyBeginAllowThreads();
25475 result = wxDateSpan::Month();
25476
25477 wxPyEndAllowThreads(__tstate);
25478 if (PyErr_Occurred()) SWIG_fail;
25479 }
25480 {
25481 wxDateSpan * resultptr;
25482 resultptr = new wxDateSpan((wxDateSpan &)(result));
25483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25484 }
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 static PyObject *_wrap_DateSpan_Years(PyObject *, PyObject *args, PyObject *kwargs) {
25492 PyObject *resultobj;
25493 int arg1 ;
25494 wxDateSpan result;
25495 PyObject * obj0 = 0 ;
25496 char *kwnames[] = {
25497 (char *) "years", NULL
25498 };
25499
25500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Years",kwnames,&obj0)) goto fail;
25501 {
25502 arg1 = (int)(SWIG_As_int(obj0));
25503 if (SWIG_arg_fail(1)) SWIG_fail;
25504 }
25505 {
25506 PyThreadState* __tstate = wxPyBeginAllowThreads();
25507 result = wxDateSpan::Years(arg1);
25508
25509 wxPyEndAllowThreads(__tstate);
25510 if (PyErr_Occurred()) SWIG_fail;
25511 }
25512 {
25513 wxDateSpan * resultptr;
25514 resultptr = new wxDateSpan((wxDateSpan &)(result));
25515 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25516 }
25517 return resultobj;
25518 fail:
25519 return NULL;
25520 }
25521
25522
25523 static PyObject *_wrap_DateSpan_Year(PyObject *, PyObject *args, PyObject *kwargs) {
25524 PyObject *resultobj;
25525 wxDateSpan result;
25526 char *kwnames[] = {
25527 NULL
25528 };
25529
25530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":DateSpan_Year",kwnames)) goto fail;
25531 {
25532 PyThreadState* __tstate = wxPyBeginAllowThreads();
25533 result = wxDateSpan::Year();
25534
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 {
25539 wxDateSpan * resultptr;
25540 resultptr = new wxDateSpan((wxDateSpan &)(result));
25541 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
25542 }
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 static PyObject *_wrap_DateSpan_SetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25550 PyObject *resultobj;
25551 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25552 int arg2 ;
25553 wxDateSpan *result;
25554 PyObject * obj0 = 0 ;
25555 PyObject * obj1 = 0 ;
25556 char *kwnames[] = {
25557 (char *) "self",(char *) "n", NULL
25558 };
25559
25560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetYears",kwnames,&obj0,&obj1)) goto fail;
25561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25562 if (SWIG_arg_fail(1)) SWIG_fail;
25563 {
25564 arg2 = (int)(SWIG_As_int(obj1));
25565 if (SWIG_arg_fail(2)) SWIG_fail;
25566 }
25567 {
25568 PyThreadState* __tstate = wxPyBeginAllowThreads();
25569 {
25570 wxDateSpan &_result_ref = (arg1)->SetYears(arg2);
25571 result = (wxDateSpan *) &_result_ref;
25572 }
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25578 return resultobj;
25579 fail:
25580 return NULL;
25581 }
25582
25583
25584 static PyObject *_wrap_DateSpan_SetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25585 PyObject *resultobj;
25586 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25587 int arg2 ;
25588 wxDateSpan *result;
25589 PyObject * obj0 = 0 ;
25590 PyObject * obj1 = 0 ;
25591 char *kwnames[] = {
25592 (char *) "self",(char *) "n", NULL
25593 };
25594
25595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetMonths",kwnames,&obj0,&obj1)) goto fail;
25596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25597 if (SWIG_arg_fail(1)) SWIG_fail;
25598 {
25599 arg2 = (int)(SWIG_As_int(obj1));
25600 if (SWIG_arg_fail(2)) SWIG_fail;
25601 }
25602 {
25603 PyThreadState* __tstate = wxPyBeginAllowThreads();
25604 {
25605 wxDateSpan &_result_ref = (arg1)->SetMonths(arg2);
25606 result = (wxDateSpan *) &_result_ref;
25607 }
25608
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 static PyObject *_wrap_DateSpan_SetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj;
25621 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25622 int arg2 ;
25623 wxDateSpan *result;
25624 PyObject * obj0 = 0 ;
25625 PyObject * obj1 = 0 ;
25626 char *kwnames[] = {
25627 (char *) "self",(char *) "n", NULL
25628 };
25629
25630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetWeeks",kwnames,&obj0,&obj1)) goto fail;
25631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25632 if (SWIG_arg_fail(1)) SWIG_fail;
25633 {
25634 arg2 = (int)(SWIG_As_int(obj1));
25635 if (SWIG_arg_fail(2)) SWIG_fail;
25636 }
25637 {
25638 PyThreadState* __tstate = wxPyBeginAllowThreads();
25639 {
25640 wxDateSpan &_result_ref = (arg1)->SetWeeks(arg2);
25641 result = (wxDateSpan *) &_result_ref;
25642 }
25643
25644 wxPyEndAllowThreads(__tstate);
25645 if (PyErr_Occurred()) SWIG_fail;
25646 }
25647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25648 return resultobj;
25649 fail:
25650 return NULL;
25651 }
25652
25653
25654 static PyObject *_wrap_DateSpan_SetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25655 PyObject *resultobj;
25656 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25657 int arg2 ;
25658 wxDateSpan *result;
25659 PyObject * obj0 = 0 ;
25660 PyObject * obj1 = 0 ;
25661 char *kwnames[] = {
25662 (char *) "self",(char *) "n", NULL
25663 };
25664
25665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_SetDays",kwnames,&obj0,&obj1)) goto fail;
25666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25667 if (SWIG_arg_fail(1)) SWIG_fail;
25668 {
25669 arg2 = (int)(SWIG_As_int(obj1));
25670 if (SWIG_arg_fail(2)) SWIG_fail;
25671 }
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 {
25675 wxDateSpan &_result_ref = (arg1)->SetDays(arg2);
25676 result = (wxDateSpan *) &_result_ref;
25677 }
25678
25679 wxPyEndAllowThreads(__tstate);
25680 if (PyErr_Occurred()) SWIG_fail;
25681 }
25682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 static PyObject *_wrap_DateSpan_GetYears(PyObject *, PyObject *args, PyObject *kwargs) {
25690 PyObject *resultobj;
25691 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25692 int result;
25693 PyObject * obj0 = 0 ;
25694 char *kwnames[] = {
25695 (char *) "self", NULL
25696 };
25697
25698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetYears",kwnames,&obj0)) goto fail;
25699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = (int)((wxDateSpan const *)arg1)->GetYears();
25704
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 {
25709 resultobj = SWIG_From_int((int)(result));
25710 }
25711 return resultobj;
25712 fail:
25713 return NULL;
25714 }
25715
25716
25717 static PyObject *_wrap_DateSpan_GetMonths(PyObject *, PyObject *args, PyObject *kwargs) {
25718 PyObject *resultobj;
25719 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25720 int result;
25721 PyObject * obj0 = 0 ;
25722 char *kwnames[] = {
25723 (char *) "self", NULL
25724 };
25725
25726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetMonths",kwnames,&obj0)) goto fail;
25727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25728 if (SWIG_arg_fail(1)) SWIG_fail;
25729 {
25730 PyThreadState* __tstate = wxPyBeginAllowThreads();
25731 result = (int)((wxDateSpan const *)arg1)->GetMonths();
25732
25733 wxPyEndAllowThreads(__tstate);
25734 if (PyErr_Occurred()) SWIG_fail;
25735 }
25736 {
25737 resultobj = SWIG_From_int((int)(result));
25738 }
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 static PyObject *_wrap_DateSpan_GetWeeks(PyObject *, PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj;
25747 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25748 int result;
25749 PyObject * obj0 = 0 ;
25750 char *kwnames[] = {
25751 (char *) "self", NULL
25752 };
25753
25754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetWeeks",kwnames,&obj0)) goto fail;
25755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25756 if (SWIG_arg_fail(1)) SWIG_fail;
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 result = (int)((wxDateSpan const *)arg1)->GetWeeks();
25760
25761 wxPyEndAllowThreads(__tstate);
25762 if (PyErr_Occurred()) SWIG_fail;
25763 }
25764 {
25765 resultobj = SWIG_From_int((int)(result));
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 static PyObject *_wrap_DateSpan_GetDays(PyObject *, PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj;
25775 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25776 int result;
25777 PyObject * obj0 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self", NULL
25780 };
25781
25782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetDays",kwnames,&obj0)) goto fail;
25783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25784 if (SWIG_arg_fail(1)) SWIG_fail;
25785 {
25786 PyThreadState* __tstate = wxPyBeginAllowThreads();
25787 result = (int)((wxDateSpan const *)arg1)->GetDays();
25788
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 {
25793 resultobj = SWIG_From_int((int)(result));
25794 }
25795 return resultobj;
25796 fail:
25797 return NULL;
25798 }
25799
25800
25801 static PyObject *_wrap_DateSpan_GetTotalDays(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj;
25803 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25804 int result;
25805 PyObject * obj0 = 0 ;
25806 char *kwnames[] = {
25807 (char *) "self", NULL
25808 };
25809
25810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_GetTotalDays",kwnames,&obj0)) goto fail;
25811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25812 if (SWIG_arg_fail(1)) SWIG_fail;
25813 {
25814 PyThreadState* __tstate = wxPyBeginAllowThreads();
25815 result = (int)((wxDateSpan const *)arg1)->GetTotalDays();
25816
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 {
25821 resultobj = SWIG_From_int((int)(result));
25822 }
25823 return resultobj;
25824 fail:
25825 return NULL;
25826 }
25827
25828
25829 static PyObject *_wrap_DateSpan_Add(PyObject *, PyObject *args, PyObject *kwargs) {
25830 PyObject *resultobj;
25831 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25832 wxDateSpan *arg2 = 0 ;
25833 wxDateSpan *result;
25834 PyObject * obj0 = 0 ;
25835 PyObject * obj1 = 0 ;
25836 char *kwnames[] = {
25837 (char *) "self",(char *) "other", NULL
25838 };
25839
25840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Add",kwnames,&obj0,&obj1)) goto fail;
25841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25842 if (SWIG_arg_fail(1)) SWIG_fail;
25843 {
25844 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25845 if (SWIG_arg_fail(2)) SWIG_fail;
25846 if (arg2 == NULL) {
25847 SWIG_null_ref("wxDateSpan");
25848 }
25849 if (SWIG_arg_fail(2)) SWIG_fail;
25850 }
25851 {
25852 PyThreadState* __tstate = wxPyBeginAllowThreads();
25853 {
25854 wxDateSpan &_result_ref = (arg1)->Add((wxDateSpan const &)*arg2);
25855 result = (wxDateSpan *) &_result_ref;
25856 }
25857
25858 wxPyEndAllowThreads(__tstate);
25859 if (PyErr_Occurred()) SWIG_fail;
25860 }
25861 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 static PyObject *_wrap_DateSpan_Subtract(PyObject *, PyObject *args, PyObject *kwargs) {
25869 PyObject *resultobj;
25870 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25871 wxDateSpan *arg2 = 0 ;
25872 wxDateSpan *result;
25873 PyObject * obj0 = 0 ;
25874 PyObject * obj1 = 0 ;
25875 char *kwnames[] = {
25876 (char *) "self",(char *) "other", NULL
25877 };
25878
25879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Subtract",kwnames,&obj0,&obj1)) goto fail;
25880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25881 if (SWIG_arg_fail(1)) SWIG_fail;
25882 {
25883 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25884 if (SWIG_arg_fail(2)) SWIG_fail;
25885 if (arg2 == NULL) {
25886 SWIG_null_ref("wxDateSpan");
25887 }
25888 if (SWIG_arg_fail(2)) SWIG_fail;
25889 }
25890 {
25891 PyThreadState* __tstate = wxPyBeginAllowThreads();
25892 {
25893 wxDateSpan &_result_ref = (arg1)->Subtract((wxDateSpan const &)*arg2);
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_Neg(PyObject *, PyObject *args, PyObject *kwargs) {
25908 PyObject *resultobj;
25909 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25910 wxDateSpan *result;
25911 PyObject * obj0 = 0 ;
25912 char *kwnames[] = {
25913 (char *) "self", NULL
25914 };
25915
25916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan_Neg",kwnames,&obj0)) goto fail;
25917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25918 if (SWIG_arg_fail(1)) SWIG_fail;
25919 {
25920 PyThreadState* __tstate = wxPyBeginAllowThreads();
25921 {
25922 wxDateSpan &_result_ref = (arg1)->Neg();
25923 result = (wxDateSpan *) &_result_ref;
25924 }
25925
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 static PyObject *_wrap_DateSpan_Multiply(PyObject *, PyObject *args, PyObject *kwargs) {
25937 PyObject *resultobj;
25938 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25939 int arg2 ;
25940 wxDateSpan *result;
25941 PyObject * obj0 = 0 ;
25942 PyObject * obj1 = 0 ;
25943 char *kwnames[] = {
25944 (char *) "self",(char *) "factor", NULL
25945 };
25946
25947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan_Multiply",kwnames,&obj0,&obj1)) goto fail;
25948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25949 if (SWIG_arg_fail(1)) SWIG_fail;
25950 {
25951 arg2 = (int)(SWIG_As_int(obj1));
25952 if (SWIG_arg_fail(2)) SWIG_fail;
25953 }
25954 {
25955 PyThreadState* __tstate = wxPyBeginAllowThreads();
25956 {
25957 wxDateSpan &_result_ref = (arg1)->Multiply(arg2);
25958 result = (wxDateSpan *) &_result_ref;
25959 }
25960
25961 wxPyEndAllowThreads(__tstate);
25962 if (PyErr_Occurred()) SWIG_fail;
25963 }
25964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
25965 return resultobj;
25966 fail:
25967 return NULL;
25968 }
25969
25970
25971 static PyObject *_wrap_DateSpan___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
25972 PyObject *resultobj;
25973 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
25974 wxDateSpan *arg2 = 0 ;
25975 wxDateSpan *result;
25976 PyObject * obj0 = 0 ;
25977 PyObject * obj1 = 0 ;
25978 char *kwnames[] = {
25979 (char *) "self",(char *) "other", NULL
25980 };
25981
25982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___iadd__",kwnames,&obj0,&obj1)) goto fail;
25983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
25984 if (SWIG_arg_fail(1)) SWIG_fail;
25985 {
25986 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
25987 if (SWIG_arg_fail(2)) SWIG_fail;
25988 if (arg2 == NULL) {
25989 SWIG_null_ref("wxDateSpan");
25990 }
25991 if (SWIG_arg_fail(2)) SWIG_fail;
25992 }
25993 {
25994 PyThreadState* __tstate = wxPyBeginAllowThreads();
25995 {
25996 wxDateSpan &_result_ref = (arg1)->operator +=((wxDateSpan const &)*arg2);
25997 result = (wxDateSpan *) &_result_ref;
25998 }
25999
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_DateSpan___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj;
26012 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26013 wxDateSpan *arg2 = 0 ;
26014 wxDateSpan *result;
26015 PyObject * obj0 = 0 ;
26016 PyObject * obj1 = 0 ;
26017 char *kwnames[] = {
26018 (char *) "self",(char *) "other", NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___isub__",kwnames,&obj0,&obj1)) goto fail;
26022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26023 if (SWIG_arg_fail(1)) SWIG_fail;
26024 {
26025 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26026 if (SWIG_arg_fail(2)) SWIG_fail;
26027 if (arg2 == NULL) {
26028 SWIG_null_ref("wxDateSpan");
26029 }
26030 if (SWIG_arg_fail(2)) SWIG_fail;
26031 }
26032 {
26033 PyThreadState* __tstate = wxPyBeginAllowThreads();
26034 {
26035 wxDateSpan &_result_ref = (arg1)->operator -=((wxDateSpan const &)*arg2);
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, 1);
26043 return resultobj;
26044 fail:
26045 return NULL;
26046 }
26047
26048
26049 static PyObject *_wrap_DateSpan___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
26050 PyObject *resultobj;
26051 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26052 wxDateSpan *result;
26053 PyObject * obj0 = 0 ;
26054 char *kwnames[] = {
26055 (char *) "self", NULL
26056 };
26057
26058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateSpan___neg__",kwnames,&obj0)) goto fail;
26059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26060 if (SWIG_arg_fail(1)) SWIG_fail;
26061 {
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 {
26064 wxDateSpan &_result_ref = (arg1)->operator -();
26065 result = (wxDateSpan *) &_result_ref;
26066 }
26067
26068 wxPyEndAllowThreads(__tstate);
26069 if (PyErr_Occurred()) SWIG_fail;
26070 }
26071 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 0);
26072 return resultobj;
26073 fail:
26074 return NULL;
26075 }
26076
26077
26078 static PyObject *_wrap_DateSpan___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
26079 PyObject *resultobj;
26080 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26081 int arg2 ;
26082 wxDateSpan *result;
26083 PyObject * obj0 = 0 ;
26084 PyObject * obj1 = 0 ;
26085 char *kwnames[] = {
26086 (char *) "self",(char *) "factor", NULL
26087 };
26088
26089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___imul__",kwnames,&obj0,&obj1)) goto fail;
26090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
26091 if (SWIG_arg_fail(1)) SWIG_fail;
26092 {
26093 arg2 = (int)(SWIG_As_int(obj1));
26094 if (SWIG_arg_fail(2)) SWIG_fail;
26095 }
26096 {
26097 PyThreadState* __tstate = wxPyBeginAllowThreads();
26098 {
26099 wxDateSpan &_result_ref = (arg1)->operator *=(arg2);
26100 result = (wxDateSpan *) &_result_ref;
26101 }
26102
26103 wxPyEndAllowThreads(__tstate);
26104 if (PyErr_Occurred()) SWIG_fail;
26105 }
26106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateSpan, 1);
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 static PyObject *_wrap_DateSpan___add__(PyObject *, PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj;
26115 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26116 wxDateSpan *arg2 = 0 ;
26117 wxDateSpan result;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char *kwnames[] = {
26121 (char *) "self",(char *) "other", NULL
26122 };
26123
26124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___add__",kwnames,&obj0,&obj1)) goto fail;
26125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(1)) SWIG_fail;
26127 {
26128 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26129 if (SWIG_arg_fail(2)) SWIG_fail;
26130 if (arg2 == NULL) {
26131 SWIG_null_ref("wxDateSpan");
26132 }
26133 if (SWIG_arg_fail(2)) SWIG_fail;
26134 }
26135 {
26136 PyThreadState* __tstate = wxPyBeginAllowThreads();
26137 result = wxDateSpan___add__(arg1,(wxDateSpan const &)*arg2);
26138
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 {
26143 wxDateSpan * resultptr;
26144 resultptr = new wxDateSpan((wxDateSpan &)(result));
26145 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26146 }
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 static PyObject *_wrap_DateSpan___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj;
26155 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26156 wxDateSpan *arg2 = 0 ;
26157 wxDateSpan result;
26158 PyObject * obj0 = 0 ;
26159 PyObject * obj1 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "other", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___sub__",kwnames,&obj0,&obj1)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26169 if (SWIG_arg_fail(2)) SWIG_fail;
26170 if (arg2 == NULL) {
26171 SWIG_null_ref("wxDateSpan");
26172 }
26173 if (SWIG_arg_fail(2)) SWIG_fail;
26174 }
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 result = wxDateSpan___sub__(arg1,(wxDateSpan const &)*arg2);
26178
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 {
26183 wxDateSpan * resultptr;
26184 resultptr = new wxDateSpan((wxDateSpan &)(result));
26185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26186 }
26187 return resultobj;
26188 fail:
26189 return NULL;
26190 }
26191
26192
26193 static PyObject *_wrap_DateSpan___mul__(PyObject *, PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj;
26195 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26196 int arg2 ;
26197 wxDateSpan result;
26198 PyObject * obj0 = 0 ;
26199 PyObject * obj1 = 0 ;
26200 char *kwnames[] = {
26201 (char *) "self",(char *) "n", NULL
26202 };
26203
26204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___mul__",kwnames,&obj0,&obj1)) goto fail;
26205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26206 if (SWIG_arg_fail(1)) SWIG_fail;
26207 {
26208 arg2 = (int)(SWIG_As_int(obj1));
26209 if (SWIG_arg_fail(2)) SWIG_fail;
26210 }
26211 {
26212 PyThreadState* __tstate = wxPyBeginAllowThreads();
26213 result = wxDateSpan___mul__(arg1,arg2);
26214
26215 wxPyEndAllowThreads(__tstate);
26216 if (PyErr_Occurred()) SWIG_fail;
26217 }
26218 {
26219 wxDateSpan * resultptr;
26220 resultptr = new wxDateSpan((wxDateSpan &)(result));
26221 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26222 }
26223 return resultobj;
26224 fail:
26225 return NULL;
26226 }
26227
26228
26229 static PyObject *_wrap_DateSpan___rmul__(PyObject *, PyObject *args, PyObject *kwargs) {
26230 PyObject *resultobj;
26231 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26232 int arg2 ;
26233 wxDateSpan result;
26234 PyObject * obj0 = 0 ;
26235 PyObject * obj1 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self",(char *) "n", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___rmul__",kwnames,&obj0,&obj1)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 arg2 = (int)(SWIG_As_int(obj1));
26245 if (SWIG_arg_fail(2)) SWIG_fail;
26246 }
26247 {
26248 PyThreadState* __tstate = wxPyBeginAllowThreads();
26249 result = wxDateSpan___rmul__(arg1,arg2);
26250
26251 wxPyEndAllowThreads(__tstate);
26252 if (PyErr_Occurred()) SWIG_fail;
26253 }
26254 {
26255 wxDateSpan * resultptr;
26256 resultptr = new wxDateSpan((wxDateSpan &)(result));
26257 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateSpan, 1);
26258 }
26259 return resultobj;
26260 fail:
26261 return NULL;
26262 }
26263
26264
26265 static PyObject *_wrap_DateSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
26266 PyObject *resultobj;
26267 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26268 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26269 bool result;
26270 PyObject * obj0 = 0 ;
26271 PyObject * obj1 = 0 ;
26272 char *kwnames[] = {
26273 (char *) "self",(char *) "other", NULL
26274 };
26275
26276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
26277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26278 if (SWIG_arg_fail(1)) SWIG_fail;
26279 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26280 if (SWIG_arg_fail(2)) SWIG_fail;
26281 {
26282 PyThreadState* __tstate = wxPyBeginAllowThreads();
26283 result = (bool)wxDateSpan___eq__(arg1,(wxDateSpan const *)arg2);
26284
26285 wxPyEndAllowThreads(__tstate);
26286 if (PyErr_Occurred()) SWIG_fail;
26287 }
26288 {
26289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26290 }
26291 return resultobj;
26292 fail:
26293 return NULL;
26294 }
26295
26296
26297 static PyObject *_wrap_DateSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
26298 PyObject *resultobj;
26299 wxDateSpan *arg1 = (wxDateSpan *) 0 ;
26300 wxDateSpan *arg2 = (wxDateSpan *) 0 ;
26301 bool result;
26302 PyObject * obj0 = 0 ;
26303 PyObject * obj1 = 0 ;
26304 char *kwnames[] = {
26305 (char *) "self",(char *) "other", NULL
26306 };
26307
26308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
26309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26310 if (SWIG_arg_fail(1)) SWIG_fail;
26311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateSpan, SWIG_POINTER_EXCEPTION | 0);
26312 if (SWIG_arg_fail(2)) SWIG_fail;
26313 {
26314 PyThreadState* __tstate = wxPyBeginAllowThreads();
26315 result = (bool)wxDateSpan___ne__(arg1,(wxDateSpan const *)arg2);
26316
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 {
26321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26322 }
26323 return resultobj;
26324 fail:
26325 return NULL;
26326 }
26327
26328
26329 static PyObject * DateSpan_swigregister(PyObject *, PyObject *args) {
26330 PyObject *obj;
26331 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26332 SWIG_TypeClientData(SWIGTYPE_p_wxDateSpan, obj);
26333 Py_INCREF(obj);
26334 return Py_BuildValue((char *)"");
26335 }
26336 static PyObject *_wrap_GetLocalTime(PyObject *, PyObject *args, PyObject *kwargs) {
26337 PyObject *resultobj;
26338 long result;
26339 char *kwnames[] = {
26340 NULL
26341 };
26342
26343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTime",kwnames)) goto fail;
26344 {
26345 PyThreadState* __tstate = wxPyBeginAllowThreads();
26346 result = (long)wxGetLocalTime();
26347
26348 wxPyEndAllowThreads(__tstate);
26349 if (PyErr_Occurred()) SWIG_fail;
26350 }
26351 {
26352 resultobj = SWIG_From_long((long)(result));
26353 }
26354 return resultobj;
26355 fail:
26356 return NULL;
26357 }
26358
26359
26360 static PyObject *_wrap_GetUTCTime(PyObject *, PyObject *args, PyObject *kwargs) {
26361 PyObject *resultobj;
26362 long result;
26363 char *kwnames[] = {
26364 NULL
26365 };
26366
26367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetUTCTime",kwnames)) goto fail;
26368 {
26369 PyThreadState* __tstate = wxPyBeginAllowThreads();
26370 result = (long)wxGetUTCTime();
26371
26372 wxPyEndAllowThreads(__tstate);
26373 if (PyErr_Occurred()) SWIG_fail;
26374 }
26375 {
26376 resultobj = SWIG_From_long((long)(result));
26377 }
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 static PyObject *_wrap_GetCurrentTime(PyObject *, PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj;
26386 long result;
26387 char *kwnames[] = {
26388 NULL
26389 };
26390
26391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetCurrentTime",kwnames)) goto fail;
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = (long)wxGetCurrentTime();
26395
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 {
26400 resultobj = SWIG_From_long((long)(result));
26401 }
26402 return resultobj;
26403 fail:
26404 return NULL;
26405 }
26406
26407
26408 static PyObject *_wrap_GetLocalTimeMillis(PyObject *, PyObject *args, PyObject *kwargs) {
26409 PyObject *resultobj;
26410 wxLongLong result;
26411 char *kwnames[] = {
26412 NULL
26413 };
26414
26415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetLocalTimeMillis",kwnames)) goto fail;
26416 {
26417 PyThreadState* __tstate = wxPyBeginAllowThreads();
26418 result = wxGetLocalTimeMillis();
26419
26420 wxPyEndAllowThreads(__tstate);
26421 if (PyErr_Occurred()) SWIG_fail;
26422 }
26423 {
26424 PyObject *hi, *lo, *shifter, *shifted;
26425 hi = PyLong_FromLong( (&result)->GetHi() );
26426 lo = PyLong_FromLong( (&result)->GetLo() );
26427 shifter = PyLong_FromLong(32);
26428 shifted = PyNumber_Lshift(hi, shifter);
26429 resultobj = PyNumber_Or(shifted, lo);
26430 Py_DECREF(hi);
26431 Py_DECREF(lo);
26432 Py_DECREF(shifter);
26433 Py_DECREF(shifted);
26434 }
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 static int _wrap_DefaultDateTime_set(PyObject *) {
26442 PyErr_SetString(PyExc_TypeError,"Variable DefaultDateTime is read-only.");
26443 return 1;
26444 }
26445
26446
26447 static PyObject *_wrap_DefaultDateTime_get(void) {
26448 PyObject *pyobj;
26449
26450 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultDateTime), SWIGTYPE_p_wxDateTime, 0);
26451 return pyobj;
26452 }
26453
26454
26455 static PyObject *_wrap_new_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26456 PyObject *resultobj;
26457 wxDataFormatId arg1 ;
26458 wxDataFormat *result;
26459 PyObject * obj0 = 0 ;
26460 char *kwnames[] = {
26461 (char *) "type", NULL
26462 };
26463
26464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_DataFormat",kwnames,&obj0)) goto fail;
26465 {
26466 arg1 = (wxDataFormatId)(SWIG_As_int(obj0));
26467 if (SWIG_arg_fail(1)) SWIG_fail;
26468 }
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 result = (wxDataFormat *)new wxDataFormat((wxDataFormatId )arg1);
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 static PyObject *_wrap_new_CustomDataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj;
26485 wxString *arg1 = 0 ;
26486 wxDataFormat *result;
26487 bool temp1 = false ;
26488 PyObject * obj0 = 0 ;
26489 char *kwnames[] = {
26490 (char *) "format", NULL
26491 };
26492
26493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_CustomDataFormat",kwnames,&obj0)) goto fail;
26494 {
26495 arg1 = wxString_in_helper(obj0);
26496 if (arg1 == NULL) SWIG_fail;
26497 temp1 = true;
26498 }
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 result = (wxDataFormat *)new wxDataFormat((wxString const &)*arg1);
26502
26503 wxPyEndAllowThreads(__tstate);
26504 if (PyErr_Occurred()) SWIG_fail;
26505 }
26506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 1);
26507 {
26508 if (temp1)
26509 delete arg1;
26510 }
26511 return resultobj;
26512 fail:
26513 {
26514 if (temp1)
26515 delete arg1;
26516 }
26517 return NULL;
26518 }
26519
26520
26521 static PyObject *_wrap_delete_DataFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj;
26523 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26524 PyObject * obj0 = 0 ;
26525 char *kwnames[] = {
26526 (char *) "self", NULL
26527 };
26528
26529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataFormat",kwnames,&obj0)) goto fail;
26530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26531 if (SWIG_arg_fail(1)) SWIG_fail;
26532 {
26533 PyThreadState* __tstate = wxPyBeginAllowThreads();
26534 delete arg1;
26535
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 Py_INCREF(Py_None); resultobj = Py_None;
26540 return resultobj;
26541 fail:
26542 return NULL;
26543 }
26544
26545
26546 static PyObject *_wrap_DataFormat___eq____SWIG_0(PyObject *, PyObject *args) {
26547 PyObject *resultobj;
26548 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26549 wxDataFormatId arg2 ;
26550 bool result;
26551 PyObject * obj0 = 0 ;
26552 PyObject * obj1 = 0 ;
26553
26554 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26556 if (SWIG_arg_fail(1)) SWIG_fail;
26557 {
26558 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26559 if (SWIG_arg_fail(2)) SWIG_fail;
26560 }
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormatId )arg2);
26564
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 {
26569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26570 }
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 static PyObject *_wrap_DataFormat___ne____SWIG_0(PyObject *, PyObject *args) {
26578 PyObject *resultobj;
26579 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26580 wxDataFormatId arg2 ;
26581 bool result;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584
26585 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26587 if (SWIG_arg_fail(1)) SWIG_fail;
26588 {
26589 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26590 if (SWIG_arg_fail(2)) SWIG_fail;
26591 }
26592 {
26593 PyThreadState* __tstate = wxPyBeginAllowThreads();
26594 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormatId )arg2);
26595
26596 wxPyEndAllowThreads(__tstate);
26597 if (PyErr_Occurred()) SWIG_fail;
26598 }
26599 {
26600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26601 }
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 static PyObject *_wrap_DataFormat___eq____SWIG_1(PyObject *, PyObject *args) {
26609 PyObject *resultobj;
26610 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26611 wxDataFormat *arg2 = 0 ;
26612 bool result;
26613 PyObject * obj0 = 0 ;
26614 PyObject * obj1 = 0 ;
26615
26616 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___eq__",&obj0,&obj1)) goto fail;
26617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26618 if (SWIG_arg_fail(1)) SWIG_fail;
26619 {
26620 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26621 if (SWIG_arg_fail(2)) SWIG_fail;
26622 if (arg2 == NULL) {
26623 SWIG_null_ref("wxDataFormat");
26624 }
26625 if (SWIG_arg_fail(2)) SWIG_fail;
26626 }
26627 {
26628 PyThreadState* __tstate = wxPyBeginAllowThreads();
26629 result = (bool)((wxDataFormat const *)arg1)->operator ==((wxDataFormat const &)*arg2);
26630
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 {
26635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26636 }
26637 return resultobj;
26638 fail:
26639 return NULL;
26640 }
26641
26642
26643 static PyObject *_wrap_DataFormat___eq__(PyObject *self, PyObject *args) {
26644 int argc;
26645 PyObject *argv[3];
26646 int ii;
26647
26648 argc = PyObject_Length(args);
26649 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26650 argv[ii] = PyTuple_GetItem(args,ii);
26651 }
26652 if (argc == 2) {
26653 int _v;
26654 {
26655 void *ptr;
26656 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26657 _v = 0;
26658 PyErr_Clear();
26659 } else {
26660 _v = 1;
26661 }
26662 }
26663 if (_v) {
26664 {
26665 void *ptr = 0;
26666 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26667 _v = 0;
26668 PyErr_Clear();
26669 } else {
26670 _v = (ptr != 0);
26671 }
26672 }
26673 if (_v) {
26674 return _wrap_DataFormat___eq____SWIG_1(self,args);
26675 }
26676 }
26677 }
26678 if (argc == 2) {
26679 int _v;
26680 {
26681 void *ptr;
26682 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26683 _v = 0;
26684 PyErr_Clear();
26685 } else {
26686 _v = 1;
26687 }
26688 }
26689 if (_v) {
26690 _v = SWIG_Check_int(argv[1]);
26691 if (_v) {
26692 return _wrap_DataFormat___eq____SWIG_0(self,args);
26693 }
26694 }
26695 }
26696
26697 Py_INCREF(Py_NotImplemented);
26698 return Py_NotImplemented;
26699 }
26700
26701
26702 static PyObject *_wrap_DataFormat___ne____SWIG_1(PyObject *, PyObject *args) {
26703 PyObject *resultobj;
26704 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26705 wxDataFormat *arg2 = 0 ;
26706 bool result;
26707 PyObject * obj0 = 0 ;
26708 PyObject * obj1 = 0 ;
26709
26710 if(!PyArg_ParseTuple(args,(char *)"OO:DataFormat___ne__",&obj0,&obj1)) goto fail;
26711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26712 if (SWIG_arg_fail(1)) SWIG_fail;
26713 {
26714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26715 if (SWIG_arg_fail(2)) SWIG_fail;
26716 if (arg2 == NULL) {
26717 SWIG_null_ref("wxDataFormat");
26718 }
26719 if (SWIG_arg_fail(2)) SWIG_fail;
26720 }
26721 {
26722 PyThreadState* __tstate = wxPyBeginAllowThreads();
26723 result = (bool)((wxDataFormat const *)arg1)->operator !=((wxDataFormat const &)*arg2);
26724
26725 wxPyEndAllowThreads(__tstate);
26726 if (PyErr_Occurred()) SWIG_fail;
26727 }
26728 {
26729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26730 }
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 static PyObject *_wrap_DataFormat___ne__(PyObject *self, PyObject *args) {
26738 int argc;
26739 PyObject *argv[3];
26740 int ii;
26741
26742 argc = PyObject_Length(args);
26743 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
26744 argv[ii] = PyTuple_GetItem(args,ii);
26745 }
26746 if (argc == 2) {
26747 int _v;
26748 {
26749 void *ptr;
26750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26751 _v = 0;
26752 PyErr_Clear();
26753 } else {
26754 _v = 1;
26755 }
26756 }
26757 if (_v) {
26758 {
26759 void *ptr = 0;
26760 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26761 _v = 0;
26762 PyErr_Clear();
26763 } else {
26764 _v = (ptr != 0);
26765 }
26766 }
26767 if (_v) {
26768 return _wrap_DataFormat___ne____SWIG_1(self,args);
26769 }
26770 }
26771 }
26772 if (argc == 2) {
26773 int _v;
26774 {
26775 void *ptr;
26776 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
26777 _v = 0;
26778 PyErr_Clear();
26779 } else {
26780 _v = 1;
26781 }
26782 }
26783 if (_v) {
26784 _v = SWIG_Check_int(argv[1]);
26785 if (_v) {
26786 return _wrap_DataFormat___ne____SWIG_0(self,args);
26787 }
26788 }
26789 }
26790
26791 Py_INCREF(Py_NotImplemented);
26792 return Py_NotImplemented;
26793 }
26794
26795
26796 static PyObject *_wrap_DataFormat_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
26797 PyObject *resultobj;
26798 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26799 wxDataFormatId arg2 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self",(char *) "format", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetType",kwnames,&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 arg2 = (wxDataFormatId)(SWIG_As_int(obj1));
26811 if (SWIG_arg_fail(2)) SWIG_fail;
26812 }
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 (arg1)->SetType((wxDataFormatId )arg2);
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 Py_INCREF(Py_None); resultobj = Py_None;
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 static PyObject *_wrap_DataFormat_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj;
26829 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26830 wxDataFormatId result;
26831 PyObject * obj0 = 0 ;
26832 char *kwnames[] = {
26833 (char *) "self", NULL
26834 };
26835
26836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetType",kwnames,&obj0)) goto fail;
26837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26838 if (SWIG_arg_fail(1)) SWIG_fail;
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 result = (wxDataFormatId)((wxDataFormat const *)arg1)->GetType();
26842
26843 wxPyEndAllowThreads(__tstate);
26844 if (PyErr_Occurred()) SWIG_fail;
26845 }
26846 resultobj = SWIG_From_int((result));
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 static PyObject *_wrap_DataFormat_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj;
26855 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26856 wxString result;
26857 PyObject * obj0 = 0 ;
26858 char *kwnames[] = {
26859 (char *) "self", NULL
26860 };
26861
26862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataFormat_GetId",kwnames,&obj0)) goto fail;
26863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26864 if (SWIG_arg_fail(1)) SWIG_fail;
26865 {
26866 PyThreadState* __tstate = wxPyBeginAllowThreads();
26867 result = ((wxDataFormat const *)arg1)->GetId();
26868
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 {
26873 #if wxUSE_UNICODE
26874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26875 #else
26876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26877 #endif
26878 }
26879 return resultobj;
26880 fail:
26881 return NULL;
26882 }
26883
26884
26885 static PyObject *_wrap_DataFormat_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26886 PyObject *resultobj;
26887 wxDataFormat *arg1 = (wxDataFormat *) 0 ;
26888 wxString *arg2 = 0 ;
26889 bool temp2 = false ;
26890 PyObject * obj0 = 0 ;
26891 PyObject * obj1 = 0 ;
26892 char *kwnames[] = {
26893 (char *) "self",(char *) "format", NULL
26894 };
26895
26896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataFormat_SetId",kwnames,&obj0,&obj1)) goto fail;
26897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
26898 if (SWIG_arg_fail(1)) SWIG_fail;
26899 {
26900 arg2 = wxString_in_helper(obj1);
26901 if (arg2 == NULL) SWIG_fail;
26902 temp2 = true;
26903 }
26904 {
26905 PyThreadState* __tstate = wxPyBeginAllowThreads();
26906 (arg1)->SetId((wxString const &)*arg2);
26907
26908 wxPyEndAllowThreads(__tstate);
26909 if (PyErr_Occurred()) SWIG_fail;
26910 }
26911 Py_INCREF(Py_None); resultobj = Py_None;
26912 {
26913 if (temp2)
26914 delete arg2;
26915 }
26916 return resultobj;
26917 fail:
26918 {
26919 if (temp2)
26920 delete arg2;
26921 }
26922 return NULL;
26923 }
26924
26925
26926 static PyObject * DataFormat_swigregister(PyObject *, PyObject *args) {
26927 PyObject *obj;
26928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
26929 SWIG_TypeClientData(SWIGTYPE_p_wxDataFormat, obj);
26930 Py_INCREF(obj);
26931 return Py_BuildValue((char *)"");
26932 }
26933 static int _wrap_FormatInvalid_set(PyObject *) {
26934 PyErr_SetString(PyExc_TypeError,"Variable FormatInvalid is read-only.");
26935 return 1;
26936 }
26937
26938
26939 static PyObject *_wrap_FormatInvalid_get(void) {
26940 PyObject *pyobj;
26941
26942 pyobj = SWIG_NewPointerObj((void *)(&wxFormatInvalid), SWIGTYPE_p_wxDataFormat, 0);
26943 return pyobj;
26944 }
26945
26946
26947 static PyObject *_wrap_delete_DataObject(PyObject *, PyObject *args, PyObject *kwargs) {
26948 PyObject *resultobj;
26949 wxDataObject *arg1 = (wxDataObject *) 0 ;
26950 PyObject * obj0 = 0 ;
26951 char *kwnames[] = {
26952 (char *) "self", NULL
26953 };
26954
26955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DataObject",kwnames,&obj0)) goto fail;
26956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26957 if (SWIG_arg_fail(1)) SWIG_fail;
26958 {
26959 PyThreadState* __tstate = wxPyBeginAllowThreads();
26960 delete arg1;
26961
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 Py_INCREF(Py_None); resultobj = Py_None;
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 static PyObject *_wrap_DataObject_GetPreferredFormat(PyObject *, PyObject *args, PyObject *kwargs) {
26973 PyObject *resultobj;
26974 wxDataObject *arg1 = (wxDataObject *) 0 ;
26975 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
26976 SwigValueWrapper<wxDataFormat > result;
26977 PyObject * obj0 = 0 ;
26978 PyObject * obj1 = 0 ;
26979 char *kwnames[] = {
26980 (char *) "self",(char *) "dir", NULL
26981 };
26982
26983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetPreferredFormat",kwnames,&obj0,&obj1)) goto fail;
26984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
26985 if (SWIG_arg_fail(1)) SWIG_fail;
26986 if (obj1) {
26987 {
26988 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
26989 if (SWIG_arg_fail(2)) SWIG_fail;
26990 }
26991 }
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 result = ((wxDataObject const *)arg1)->GetPreferredFormat((wxDataObject::Direction )arg2);
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 {
27000 wxDataFormat * resultptr;
27001 resultptr = new wxDataFormat((wxDataFormat &)(result));
27002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDataFormat, 1);
27003 }
27004 return resultobj;
27005 fail:
27006 return NULL;
27007 }
27008
27009
27010 static PyObject *_wrap_DataObject_GetFormatCount(PyObject *, PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj;
27012 wxDataObject *arg1 = (wxDataObject *) 0 ;
27013 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27014 size_t result;
27015 PyObject * obj0 = 0 ;
27016 PyObject * obj1 = 0 ;
27017 char *kwnames[] = {
27018 (char *) "self",(char *) "dir", NULL
27019 };
27020
27021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetFormatCount",kwnames,&obj0,&obj1)) goto fail;
27022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27023 if (SWIG_arg_fail(1)) SWIG_fail;
27024 if (obj1) {
27025 {
27026 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27027 if (SWIG_arg_fail(2)) SWIG_fail;
27028 }
27029 }
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 result = (size_t)((wxDataObject const *)arg1)->GetFormatCount((wxDataObject::Direction )arg2);
27033
27034 wxPyEndAllowThreads(__tstate);
27035 if (PyErr_Occurred()) SWIG_fail;
27036 }
27037 {
27038 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27039 }
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 static PyObject *_wrap_DataObject_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
27047 PyObject *resultobj;
27048 wxDataObject *arg1 = (wxDataObject *) 0 ;
27049 wxDataFormat *arg2 = 0 ;
27050 wxDataObject::Direction arg3 = (wxDataObject::Direction) wxDataObject::Get ;
27051 bool result;
27052 PyObject * obj0 = 0 ;
27053 PyObject * obj1 = 0 ;
27054 PyObject * obj2 = 0 ;
27055 char *kwnames[] = {
27056 (char *) "self",(char *) "format",(char *) "dir", NULL
27057 };
27058
27059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObject_IsSupported",kwnames,&obj0,&obj1,&obj2)) goto fail;
27060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27061 if (SWIG_arg_fail(1)) SWIG_fail;
27062 {
27063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27064 if (SWIG_arg_fail(2)) SWIG_fail;
27065 if (arg2 == NULL) {
27066 SWIG_null_ref("wxDataFormat");
27067 }
27068 if (SWIG_arg_fail(2)) SWIG_fail;
27069 }
27070 if (obj2) {
27071 {
27072 arg3 = (wxDataObject::Direction)(SWIG_As_int(obj2));
27073 if (SWIG_arg_fail(3)) SWIG_fail;
27074 }
27075 }
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = (bool)((wxDataObject const *)arg1)->IsSupported((wxDataFormat const &)*arg2,(wxDataObject::Direction )arg3);
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27085 }
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 static PyObject *_wrap_DataObject_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj;
27094 wxDataObject *arg1 = (wxDataObject *) 0 ;
27095 wxDataFormat *arg2 = 0 ;
27096 size_t result;
27097 PyObject * obj0 = 0 ;
27098 PyObject * obj1 = 0 ;
27099 char *kwnames[] = {
27100 (char *) "self",(char *) "format", NULL
27101 };
27102
27103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataSize",kwnames,&obj0,&obj1)) goto fail;
27104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27105 if (SWIG_arg_fail(1)) SWIG_fail;
27106 {
27107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27108 if (SWIG_arg_fail(2)) SWIG_fail;
27109 if (arg2 == NULL) {
27110 SWIG_null_ref("wxDataFormat");
27111 }
27112 if (SWIG_arg_fail(2)) SWIG_fail;
27113 }
27114 {
27115 PyThreadState* __tstate = wxPyBeginAllowThreads();
27116 result = (size_t)((wxDataObject const *)arg1)->GetDataSize((wxDataFormat const &)*arg2);
27117
27118 wxPyEndAllowThreads(__tstate);
27119 if (PyErr_Occurred()) SWIG_fail;
27120 }
27121 {
27122 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27123 }
27124 return resultobj;
27125 fail:
27126 return NULL;
27127 }
27128
27129
27130 static PyObject *_wrap_DataObject_GetAllFormats(PyObject *, PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj;
27132 wxDataObject *arg1 = (wxDataObject *) 0 ;
27133 wxDataObject::Direction arg2 = (wxDataObject::Direction) wxDataObject::Get ;
27134 PyObject *result;
27135 PyObject * obj0 = 0 ;
27136 PyObject * obj1 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self",(char *) "dir", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DataObject_GetAllFormats",kwnames,&obj0,&obj1)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 if (obj1) {
27145 {
27146 arg2 = (wxDataObject::Direction)(SWIG_As_int(obj1));
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 }
27149 }
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 result = (PyObject *)wxDataObject_GetAllFormats(arg1,(wxDataObject::Direction )arg2);
27153
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 resultobj = result;
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 static PyObject *_wrap_DataObject_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj;
27166 wxDataObject *arg1 = (wxDataObject *) 0 ;
27167 wxDataFormat *arg2 = 0 ;
27168 PyObject *result;
27169 PyObject * obj0 = 0 ;
27170 PyObject * obj1 = 0 ;
27171 char *kwnames[] = {
27172 (char *) "self",(char *) "format", NULL
27173 };
27174
27175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObject_GetDataHere",kwnames,&obj0,&obj1)) goto fail;
27176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27177 if (SWIG_arg_fail(1)) SWIG_fail;
27178 {
27179 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27180 if (SWIG_arg_fail(2)) SWIG_fail;
27181 if (arg2 == NULL) {
27182 SWIG_null_ref("wxDataFormat");
27183 }
27184 if (SWIG_arg_fail(2)) SWIG_fail;
27185 }
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 result = (PyObject *)wxDataObject_GetDataHere(arg1,(wxDataFormat const &)*arg2);
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 resultobj = result;
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 static PyObject *_wrap_DataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27201 PyObject *resultobj;
27202 wxDataObject *arg1 = (wxDataObject *) 0 ;
27203 wxDataFormat *arg2 = 0 ;
27204 PyObject *arg3 = (PyObject *) 0 ;
27205 bool result;
27206 PyObject * obj0 = 0 ;
27207 PyObject * obj1 = 0 ;
27208 PyObject * obj2 = 0 ;
27209 char *kwnames[] = {
27210 (char *) "self",(char *) "format",(char *) "data", NULL
27211 };
27212
27213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DataObject_SetData",kwnames,&obj0,&obj1,&obj2)) goto fail;
27214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
27215 if (SWIG_arg_fail(1)) SWIG_fail;
27216 {
27217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27218 if (SWIG_arg_fail(2)) SWIG_fail;
27219 if (arg2 == NULL) {
27220 SWIG_null_ref("wxDataFormat");
27221 }
27222 if (SWIG_arg_fail(2)) SWIG_fail;
27223 }
27224 arg3 = obj2;
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = (bool)wxDataObject_SetData(arg1,(wxDataFormat const &)*arg2,arg3);
27228
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 {
27233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27234 }
27235 return resultobj;
27236 fail:
27237 return NULL;
27238 }
27239
27240
27241 static PyObject * DataObject_swigregister(PyObject *, PyObject *args) {
27242 PyObject *obj;
27243 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27244 SWIG_TypeClientData(SWIGTYPE_p_wxDataObject, obj);
27245 Py_INCREF(obj);
27246 return Py_BuildValue((char *)"");
27247 }
27248 static PyObject *_wrap_new_DataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj;
27250 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27251 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27252 wxDataObjectSimple *result;
27253 PyObject * obj0 = 0 ;
27254 char *kwnames[] = {
27255 (char *) "format", NULL
27256 };
27257
27258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DataObjectSimple",kwnames,&obj0)) goto fail;
27259 if (obj0) {
27260 {
27261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27262 if (SWIG_arg_fail(1)) SWIG_fail;
27263 if (arg1 == NULL) {
27264 SWIG_null_ref("wxDataFormat");
27265 }
27266 if (SWIG_arg_fail(1)) SWIG_fail;
27267 }
27268 }
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 result = (wxDataObjectSimple *)new wxDataObjectSimple((wxDataFormat const &)*arg1);
27272
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectSimple, 1);
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_DataObjectSimple_GetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27286 wxDataFormat *result;
27287 PyObject * obj0 = 0 ;
27288 char *kwnames[] = {
27289 (char *) "self", NULL
27290 };
27291
27292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetFormat",kwnames,&obj0)) goto fail;
27293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27294 if (SWIG_arg_fail(1)) SWIG_fail;
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 {
27298 wxDataFormat const &_result_ref = (arg1)->GetFormat();
27299 result = (wxDataFormat *) &_result_ref;
27300 }
27301
27302 wxPyEndAllowThreads(__tstate);
27303 if (PyErr_Occurred()) SWIG_fail;
27304 }
27305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataFormat, 0);
27306 return resultobj;
27307 fail:
27308 return NULL;
27309 }
27310
27311
27312 static PyObject *_wrap_DataObjectSimple_SetFormat(PyObject *, PyObject *args, PyObject *kwargs) {
27313 PyObject *resultobj;
27314 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27315 wxDataFormat *arg2 = 0 ;
27316 PyObject * obj0 = 0 ;
27317 PyObject * obj1 = 0 ;
27318 char *kwnames[] = {
27319 (char *) "self",(char *) "format", NULL
27320 };
27321
27322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetFormat",kwnames,&obj0,&obj1)) goto fail;
27323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27324 if (SWIG_arg_fail(1)) SWIG_fail;
27325 {
27326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27327 if (SWIG_arg_fail(2)) SWIG_fail;
27328 if (arg2 == NULL) {
27329 SWIG_null_ref("wxDataFormat");
27330 }
27331 if (SWIG_arg_fail(2)) SWIG_fail;
27332 }
27333 {
27334 PyThreadState* __tstate = wxPyBeginAllowThreads();
27335 (arg1)->SetFormat((wxDataFormat const &)*arg2);
27336
27337 wxPyEndAllowThreads(__tstate);
27338 if (PyErr_Occurred()) SWIG_fail;
27339 }
27340 Py_INCREF(Py_None); resultobj = Py_None;
27341 return resultobj;
27342 fail:
27343 return NULL;
27344 }
27345
27346
27347 static PyObject *_wrap_DataObjectSimple_GetDataSize(PyObject *, PyObject *args, PyObject *kwargs) {
27348 PyObject *resultobj;
27349 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27350 size_t result;
27351 PyObject * obj0 = 0 ;
27352 char *kwnames[] = {
27353 (char *) "self", NULL
27354 };
27355
27356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataSize",kwnames,&obj0)) goto fail;
27357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27358 if (SWIG_arg_fail(1)) SWIG_fail;
27359 {
27360 PyThreadState* __tstate = wxPyBeginAllowThreads();
27361 result = (size_t)((wxDataObjectSimple const *)arg1)->GetDataSize();
27362
27363 wxPyEndAllowThreads(__tstate);
27364 if (PyErr_Occurred()) SWIG_fail;
27365 }
27366 {
27367 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27368 }
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_DataObjectSimple_GetDataHere(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj;
27377 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27378 PyObject *result;
27379 PyObject * obj0 = 0 ;
27380 char *kwnames[] = {
27381 (char *) "self", NULL
27382 };
27383
27384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DataObjectSimple_GetDataHere",kwnames,&obj0)) goto fail;
27385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27386 if (SWIG_arg_fail(1)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (PyObject *)wxDataObjectSimple_GetDataHere(arg1);
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 resultobj = result;
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 static PyObject *_wrap_DataObjectSimple_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
27402 PyObject *resultobj;
27403 wxDataObjectSimple *arg1 = (wxDataObjectSimple *) 0 ;
27404 PyObject *arg2 = (PyObject *) 0 ;
27405 bool result;
27406 PyObject * obj0 = 0 ;
27407 PyObject * obj1 = 0 ;
27408 char *kwnames[] = {
27409 (char *) "self",(char *) "data", NULL
27410 };
27411
27412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DataObjectSimple_SetData",kwnames,&obj0,&obj1)) goto fail;
27413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27414 if (SWIG_arg_fail(1)) SWIG_fail;
27415 arg2 = obj1;
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 result = (bool)wxDataObjectSimple_SetData(arg1,arg2);
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 {
27424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27425 }
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 static PyObject * DataObjectSimple_swigregister(PyObject *, PyObject *args) {
27433 PyObject *obj;
27434 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27435 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectSimple, obj);
27436 Py_INCREF(obj);
27437 return Py_BuildValue((char *)"");
27438 }
27439 static PyObject *_wrap_new_PyDataObjectSimple(PyObject *, PyObject *args, PyObject *kwargs) {
27440 PyObject *resultobj;
27441 wxDataFormat const &arg1_defvalue = wxFormatInvalid ;
27442 wxDataFormat *arg1 = (wxDataFormat *) &arg1_defvalue ;
27443 wxPyDataObjectSimple *result;
27444 PyObject * obj0 = 0 ;
27445 char *kwnames[] = {
27446 (char *) "format", NULL
27447 };
27448
27449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDataObjectSimple",kwnames,&obj0)) goto fail;
27450 if (obj0) {
27451 {
27452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(1)) SWIG_fail;
27454 if (arg1 == NULL) {
27455 SWIG_null_ref("wxDataFormat");
27456 }
27457 if (SWIG_arg_fail(1)) SWIG_fail;
27458 }
27459 }
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (wxPyDataObjectSimple *)new wxPyDataObjectSimple((wxDataFormat const &)*arg1);
27463
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDataObjectSimple, 1);
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_PyDataObjectSimple__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj;
27476 wxPyDataObjectSimple *arg1 = (wxPyDataObjectSimple *) 0 ;
27477 PyObject *arg2 = (PyObject *) 0 ;
27478 PyObject *arg3 = (PyObject *) 0 ;
27479 PyObject * obj0 = 0 ;
27480 PyObject * obj1 = 0 ;
27481 PyObject * obj2 = 0 ;
27482 char *kwnames[] = {
27483 (char *) "self",(char *) "self",(char *) "_class", NULL
27484 };
27485
27486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyDataObjectSimple__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDataObjectSimple, SWIG_POINTER_EXCEPTION | 0);
27488 if (SWIG_arg_fail(1)) SWIG_fail;
27489 arg2 = obj1;
27490 arg3 = obj2;
27491 {
27492 PyThreadState* __tstate = wxPyBeginAllowThreads();
27493 (arg1)->_setCallbackInfo(arg2,arg3);
27494
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 Py_INCREF(Py_None); resultobj = Py_None;
27499 return resultobj;
27500 fail:
27501 return NULL;
27502 }
27503
27504
27505 static PyObject * PyDataObjectSimple_swigregister(PyObject *, PyObject *args) {
27506 PyObject *obj;
27507 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27508 SWIG_TypeClientData(SWIGTYPE_p_wxPyDataObjectSimple, obj);
27509 Py_INCREF(obj);
27510 return Py_BuildValue((char *)"");
27511 }
27512 static PyObject *_wrap_new_DataObjectComposite(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj;
27514 wxDataObjectComposite *result;
27515 char *kwnames[] = {
27516 NULL
27517 };
27518
27519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DataObjectComposite",kwnames)) goto fail;
27520 {
27521 PyThreadState* __tstate = wxPyBeginAllowThreads();
27522 result = (wxDataObjectComposite *)new wxDataObjectComposite();
27523
27524 wxPyEndAllowThreads(__tstate);
27525 if (PyErr_Occurred()) SWIG_fail;
27526 }
27527 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObjectComposite, 1);
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_DataObjectComposite_Add(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxDataObjectComposite *arg1 = (wxDataObjectComposite *) 0 ;
27537 wxDataObjectSimple *arg2 = (wxDataObjectSimple *) 0 ;
27538 bool arg3 = (bool) false ;
27539 PyObject * obj0 = 0 ;
27540 PyObject * obj1 = 0 ;
27541 PyObject * obj2 = 0 ;
27542 char *kwnames[] = {
27543 (char *) "self",(char *) "dataObject",(char *) "preferred", NULL
27544 };
27545
27546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:DataObjectComposite_Add",kwnames,&obj0,&obj1,&obj2)) goto fail;
27547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObjectComposite, SWIG_POINTER_EXCEPTION | 0);
27548 if (SWIG_arg_fail(1)) SWIG_fail;
27549 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObjectSimple, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
27550 if (SWIG_arg_fail(2)) SWIG_fail;
27551 if (obj2) {
27552 {
27553 arg3 = (bool)(SWIG_As_bool(obj2));
27554 if (SWIG_arg_fail(3)) SWIG_fail;
27555 }
27556 }
27557 {
27558 PyThreadState* __tstate = wxPyBeginAllowThreads();
27559 (arg1)->Add(arg2,arg3);
27560
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 Py_INCREF(Py_None); resultobj = Py_None;
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 static PyObject * DataObjectComposite_swigregister(PyObject *, PyObject *args) {
27572 PyObject *obj;
27573 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27574 SWIG_TypeClientData(SWIGTYPE_p_wxDataObjectComposite, obj);
27575 Py_INCREF(obj);
27576 return Py_BuildValue((char *)"");
27577 }
27578 static PyObject *_wrap_new_TextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27579 PyObject *resultobj;
27580 wxString const &arg1_defvalue = wxPyEmptyString ;
27581 wxString *arg1 = (wxString *) &arg1_defvalue ;
27582 wxTextDataObject *result;
27583 bool temp1 = false ;
27584 PyObject * obj0 = 0 ;
27585 char *kwnames[] = {
27586 (char *) "text", NULL
27587 };
27588
27589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_TextDataObject",kwnames,&obj0)) goto fail;
27590 if (obj0) {
27591 {
27592 arg1 = wxString_in_helper(obj0);
27593 if (arg1 == NULL) SWIG_fail;
27594 temp1 = true;
27595 }
27596 }
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (wxTextDataObject *)new wxTextDataObject((wxString const &)*arg1);
27600
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTextDataObject, 1);
27605 {
27606 if (temp1)
27607 delete arg1;
27608 }
27609 return resultobj;
27610 fail:
27611 {
27612 if (temp1)
27613 delete arg1;
27614 }
27615 return NULL;
27616 }
27617
27618
27619 static PyObject *_wrap_TextDataObject_GetTextLength(PyObject *, PyObject *args, PyObject *kwargs) {
27620 PyObject *resultobj;
27621 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27622 size_t result;
27623 PyObject * obj0 = 0 ;
27624 char *kwnames[] = {
27625 (char *) "self", NULL
27626 };
27627
27628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetTextLength",kwnames,&obj0)) goto fail;
27629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27630 if (SWIG_arg_fail(1)) SWIG_fail;
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 result = (size_t)(arg1)->GetTextLength();
27634
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 {
27639 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
27640 }
27641 return resultobj;
27642 fail:
27643 return NULL;
27644 }
27645
27646
27647 static PyObject *_wrap_TextDataObject_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
27648 PyObject *resultobj;
27649 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27650 wxString result;
27651 PyObject * obj0 = 0 ;
27652 char *kwnames[] = {
27653 (char *) "self", NULL
27654 };
27655
27656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDataObject_GetText",kwnames,&obj0)) goto fail;
27657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27658 if (SWIG_arg_fail(1)) SWIG_fail;
27659 {
27660 PyThreadState* __tstate = wxPyBeginAllowThreads();
27661 result = (arg1)->GetText();
27662
27663 wxPyEndAllowThreads(__tstate);
27664 if (PyErr_Occurred()) SWIG_fail;
27665 }
27666 {
27667 #if wxUSE_UNICODE
27668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27669 #else
27670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27671 #endif
27672 }
27673 return resultobj;
27674 fail:
27675 return NULL;
27676 }
27677
27678
27679 static PyObject *_wrap_TextDataObject_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
27680 PyObject *resultobj;
27681 wxTextDataObject *arg1 = (wxTextDataObject *) 0 ;
27682 wxString *arg2 = 0 ;
27683 bool temp2 = false ;
27684 PyObject * obj0 = 0 ;
27685 PyObject * obj1 = 0 ;
27686 char *kwnames[] = {
27687 (char *) "self",(char *) "text", NULL
27688 };
27689
27690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TextDataObject_SetText",kwnames,&obj0,&obj1)) goto fail;
27691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27692 if (SWIG_arg_fail(1)) SWIG_fail;
27693 {
27694 arg2 = wxString_in_helper(obj1);
27695 if (arg2 == NULL) SWIG_fail;
27696 temp2 = true;
27697 }
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 (arg1)->SetText((wxString const &)*arg2);
27701
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 Py_INCREF(Py_None); resultobj = Py_None;
27706 {
27707 if (temp2)
27708 delete arg2;
27709 }
27710 return resultobj;
27711 fail:
27712 {
27713 if (temp2)
27714 delete arg2;
27715 }
27716 return NULL;
27717 }
27718
27719
27720 static PyObject * TextDataObject_swigregister(PyObject *, PyObject *args) {
27721 PyObject *obj;
27722 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27723 SWIG_TypeClientData(SWIGTYPE_p_wxTextDataObject, obj);
27724 Py_INCREF(obj);
27725 return Py_BuildValue((char *)"");
27726 }
27727 static PyObject *_wrap_new_PyTextDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27728 PyObject *resultobj;
27729 wxString const &arg1_defvalue = wxPyEmptyString ;
27730 wxString *arg1 = (wxString *) &arg1_defvalue ;
27731 wxPyTextDataObject *result;
27732 bool temp1 = false ;
27733 PyObject * obj0 = 0 ;
27734 char *kwnames[] = {
27735 (char *) "text", NULL
27736 };
27737
27738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyTextDataObject",kwnames,&obj0)) goto fail;
27739 if (obj0) {
27740 {
27741 arg1 = wxString_in_helper(obj0);
27742 if (arg1 == NULL) SWIG_fail;
27743 temp1 = true;
27744 }
27745 }
27746 {
27747 PyThreadState* __tstate = wxPyBeginAllowThreads();
27748 result = (wxPyTextDataObject *)new wxPyTextDataObject((wxString const &)*arg1);
27749
27750 wxPyEndAllowThreads(__tstate);
27751 if (PyErr_Occurred()) SWIG_fail;
27752 }
27753 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDataObject, 1);
27754 {
27755 if (temp1)
27756 delete arg1;
27757 }
27758 return resultobj;
27759 fail:
27760 {
27761 if (temp1)
27762 delete arg1;
27763 }
27764 return NULL;
27765 }
27766
27767
27768 static PyObject *_wrap_PyTextDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27769 PyObject *resultobj;
27770 wxPyTextDataObject *arg1 = (wxPyTextDataObject *) 0 ;
27771 PyObject *arg2 = (PyObject *) 0 ;
27772 PyObject *arg3 = (PyObject *) 0 ;
27773 PyObject * obj0 = 0 ;
27774 PyObject * obj1 = 0 ;
27775 PyObject * obj2 = 0 ;
27776 char *kwnames[] = {
27777 (char *) "self",(char *) "self",(char *) "_class", NULL
27778 };
27779
27780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyTextDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDataObject, SWIG_POINTER_EXCEPTION | 0);
27782 if (SWIG_arg_fail(1)) SWIG_fail;
27783 arg2 = obj1;
27784 arg3 = obj2;
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 (arg1)->_setCallbackInfo(arg2,arg3);
27788
27789 wxPyEndAllowThreads(__tstate);
27790 if (PyErr_Occurred()) SWIG_fail;
27791 }
27792 Py_INCREF(Py_None); resultobj = Py_None;
27793 return resultobj;
27794 fail:
27795 return NULL;
27796 }
27797
27798
27799 static PyObject * PyTextDataObject_swigregister(PyObject *, PyObject *args) {
27800 PyObject *obj;
27801 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27802 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDataObject, obj);
27803 Py_INCREF(obj);
27804 return Py_BuildValue((char *)"");
27805 }
27806 static PyObject *_wrap_new_BitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27807 PyObject *resultobj;
27808 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27809 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27810 wxBitmapDataObject *result;
27811 PyObject * obj0 = 0 ;
27812 char *kwnames[] = {
27813 (char *) "bitmap", NULL
27814 };
27815
27816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BitmapDataObject",kwnames,&obj0)) goto fail;
27817 if (obj0) {
27818 {
27819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27820 if (SWIG_arg_fail(1)) SWIG_fail;
27821 if (arg1 == NULL) {
27822 SWIG_null_ref("wxBitmap");
27823 }
27824 if (SWIG_arg_fail(1)) SWIG_fail;
27825 }
27826 }
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = (wxBitmapDataObject *)new wxBitmapDataObject((wxBitmap const &)*arg1);
27830
27831 wxPyEndAllowThreads(__tstate);
27832 if (PyErr_Occurred()) SWIG_fail;
27833 }
27834 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBitmapDataObject, 1);
27835 return resultobj;
27836 fail:
27837 return NULL;
27838 }
27839
27840
27841 static PyObject *_wrap_BitmapDataObject_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27842 PyObject *resultobj;
27843 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27844 wxBitmap result;
27845 PyObject * obj0 = 0 ;
27846 char *kwnames[] = {
27847 (char *) "self", NULL
27848 };
27849
27850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BitmapDataObject_GetBitmap",kwnames,&obj0)) goto fail;
27851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27852 if (SWIG_arg_fail(1)) SWIG_fail;
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 result = ((wxBitmapDataObject const *)arg1)->GetBitmap();
27856
27857 wxPyEndAllowThreads(__tstate);
27858 if (PyErr_Occurred()) SWIG_fail;
27859 }
27860 {
27861 wxBitmap * resultptr;
27862 resultptr = new wxBitmap((wxBitmap &)(result));
27863 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
27864 }
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 static PyObject *_wrap_BitmapDataObject_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
27872 PyObject *resultobj;
27873 wxBitmapDataObject *arg1 = (wxBitmapDataObject *) 0 ;
27874 wxBitmap *arg2 = 0 ;
27875 PyObject * obj0 = 0 ;
27876 PyObject * obj1 = 0 ;
27877 char *kwnames[] = {
27878 (char *) "self",(char *) "bitmap", NULL
27879 };
27880
27881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BitmapDataObject_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
27882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27883 if (SWIG_arg_fail(1)) SWIG_fail;
27884 {
27885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27886 if (SWIG_arg_fail(2)) SWIG_fail;
27887 if (arg2 == NULL) {
27888 SWIG_null_ref("wxBitmap");
27889 }
27890 if (SWIG_arg_fail(2)) SWIG_fail;
27891 }
27892 {
27893 PyThreadState* __tstate = wxPyBeginAllowThreads();
27894 (arg1)->SetBitmap((wxBitmap const &)*arg2);
27895
27896 wxPyEndAllowThreads(__tstate);
27897 if (PyErr_Occurred()) SWIG_fail;
27898 }
27899 Py_INCREF(Py_None); resultobj = Py_None;
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 static PyObject * BitmapDataObject_swigregister(PyObject *, PyObject *args) {
27907 PyObject *obj;
27908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27909 SWIG_TypeClientData(SWIGTYPE_p_wxBitmapDataObject, obj);
27910 Py_INCREF(obj);
27911 return Py_BuildValue((char *)"");
27912 }
27913 static PyObject *_wrap_new_PyBitmapDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27914 PyObject *resultobj;
27915 wxBitmap const &arg1_defvalue = wxNullBitmap ;
27916 wxBitmap *arg1 = (wxBitmap *) &arg1_defvalue ;
27917 wxPyBitmapDataObject *result;
27918 PyObject * obj0 = 0 ;
27919 char *kwnames[] = {
27920 (char *) "bitmap", NULL
27921 };
27922
27923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyBitmapDataObject",kwnames,&obj0)) goto fail;
27924 if (obj0) {
27925 {
27926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
27927 if (SWIG_arg_fail(1)) SWIG_fail;
27928 if (arg1 == NULL) {
27929 SWIG_null_ref("wxBitmap");
27930 }
27931 if (SWIG_arg_fail(1)) SWIG_fail;
27932 }
27933 }
27934 {
27935 PyThreadState* __tstate = wxPyBeginAllowThreads();
27936 result = (wxPyBitmapDataObject *)new wxPyBitmapDataObject((wxBitmap const &)*arg1);
27937
27938 wxPyEndAllowThreads(__tstate);
27939 if (PyErr_Occurred()) SWIG_fail;
27940 }
27941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyBitmapDataObject, 1);
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 static PyObject *_wrap_PyBitmapDataObject__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj;
27950 wxPyBitmapDataObject *arg1 = (wxPyBitmapDataObject *) 0 ;
27951 PyObject *arg2 = (PyObject *) 0 ;
27952 PyObject *arg3 = (PyObject *) 0 ;
27953 PyObject * obj0 = 0 ;
27954 PyObject * obj1 = 0 ;
27955 PyObject * obj2 = 0 ;
27956 char *kwnames[] = {
27957 (char *) "self",(char *) "self",(char *) "_class", NULL
27958 };
27959
27960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyBitmapDataObject__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
27961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyBitmapDataObject, SWIG_POINTER_EXCEPTION | 0);
27962 if (SWIG_arg_fail(1)) SWIG_fail;
27963 arg2 = obj1;
27964 arg3 = obj2;
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 (arg1)->_setCallbackInfo(arg2,arg3);
27968
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 Py_INCREF(Py_None); resultobj = Py_None;
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 static PyObject * PyBitmapDataObject_swigregister(PyObject *, PyObject *args) {
27980 PyObject *obj;
27981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
27982 SWIG_TypeClientData(SWIGTYPE_p_wxPyBitmapDataObject, obj);
27983 Py_INCREF(obj);
27984 return Py_BuildValue((char *)"");
27985 }
27986 static PyObject *_wrap_new_FileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
27987 PyObject *resultobj;
27988 wxFileDataObject *result;
27989 char *kwnames[] = {
27990 NULL
27991 };
27992
27993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDataObject",kwnames)) goto fail;
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 result = (wxFileDataObject *)new wxFileDataObject();
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFileDataObject, 1);
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 static PyObject *_wrap_FileDataObject_GetFilenames(PyObject *, PyObject *args, PyObject *kwargs) {
28009 PyObject *resultobj;
28010 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28011 wxArrayString *result;
28012 PyObject * obj0 = 0 ;
28013 char *kwnames[] = {
28014 (char *) "self", NULL
28015 };
28016
28017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDataObject_GetFilenames",kwnames,&obj0)) goto fail;
28018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28019 if (SWIG_arg_fail(1)) SWIG_fail;
28020 {
28021 PyThreadState* __tstate = wxPyBeginAllowThreads();
28022 {
28023 wxArrayString const &_result_ref = (arg1)->GetFilenames();
28024 result = (wxArrayString *) &_result_ref;
28025 }
28026
28027 wxPyEndAllowThreads(__tstate);
28028 if (PyErr_Occurred()) SWIG_fail;
28029 }
28030 {
28031 resultobj = wxArrayString2PyList_helper(*result);
28032 }
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 static PyObject *_wrap_FileDataObject_AddFile(PyObject *, PyObject *args, PyObject *kwargs) {
28040 PyObject *resultobj;
28041 wxFileDataObject *arg1 = (wxFileDataObject *) 0 ;
28042 wxString *arg2 = 0 ;
28043 bool temp2 = false ;
28044 PyObject * obj0 = 0 ;
28045 PyObject * obj1 = 0 ;
28046 char *kwnames[] = {
28047 (char *) "self",(char *) "filename", NULL
28048 };
28049
28050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileDataObject_AddFile",kwnames,&obj0,&obj1)) goto fail;
28051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileDataObject, SWIG_POINTER_EXCEPTION | 0);
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 {
28054 arg2 = wxString_in_helper(obj1);
28055 if (arg2 == NULL) SWIG_fail;
28056 temp2 = true;
28057 }
28058 {
28059 PyThreadState* __tstate = wxPyBeginAllowThreads();
28060 (arg1)->AddFile((wxString const &)*arg2);
28061
28062 wxPyEndAllowThreads(__tstate);
28063 if (PyErr_Occurred()) SWIG_fail;
28064 }
28065 Py_INCREF(Py_None); resultobj = Py_None;
28066 {
28067 if (temp2)
28068 delete arg2;
28069 }
28070 return resultobj;
28071 fail:
28072 {
28073 if (temp2)
28074 delete arg2;
28075 }
28076 return NULL;
28077 }
28078
28079
28080 static PyObject * FileDataObject_swigregister(PyObject *, PyObject *args) {
28081 PyObject *obj;
28082 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28083 SWIG_TypeClientData(SWIGTYPE_p_wxFileDataObject, obj);
28084 Py_INCREF(obj);
28085 return Py_BuildValue((char *)"");
28086 }
28087 static PyObject *_wrap_new_CustomDataObject__SWIG_0(PyObject *, PyObject *args) {
28088 PyObject *resultobj;
28089 wxDataFormat *arg1 = 0 ;
28090 wxCustomDataObject *result;
28091 PyObject * obj0 = 0 ;
28092
28093 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28094 {
28095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
28096 if (SWIG_arg_fail(1)) SWIG_fail;
28097 if (arg1 == NULL) {
28098 SWIG_null_ref("wxDataFormat");
28099 }
28100 if (SWIG_arg_fail(1)) SWIG_fail;
28101 }
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = (wxCustomDataObject *)new wxCustomDataObject((wxDataFormat const &)*arg1);
28105
28106 wxPyEndAllowThreads(__tstate);
28107 if (PyErr_Occurred()) SWIG_fail;
28108 }
28109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28110 return resultobj;
28111 fail:
28112 return NULL;
28113 }
28114
28115
28116 static PyObject *_wrap_new_CustomDataObject__SWIG_1(PyObject *, PyObject *args) {
28117 PyObject *resultobj;
28118 wxString *arg1 = 0 ;
28119 wxCustomDataObject *result;
28120 bool temp1 = false ;
28121 PyObject * obj0 = 0 ;
28122
28123 if(!PyArg_ParseTuple(args,(char *)"O:new_CustomDataObject",&obj0)) goto fail;
28124 {
28125 arg1 = wxString_in_helper(obj0);
28126 if (arg1 == NULL) SWIG_fail;
28127 temp1 = true;
28128 }
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (wxCustomDataObject *)new_wxCustomDataObject__SWIG_1((wxString const &)*arg1);
28132
28133 wxPyEndAllowThreads(__tstate);
28134 if (PyErr_Occurred()) SWIG_fail;
28135 }
28136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28137 {
28138 if (temp1)
28139 delete arg1;
28140 }
28141 return resultobj;
28142 fail:
28143 {
28144 if (temp1)
28145 delete arg1;
28146 }
28147 return NULL;
28148 }
28149
28150
28151 static PyObject *_wrap_new_CustomDataObject__SWIG_2(PyObject *, PyObject *args) {
28152 PyObject *resultobj;
28153 wxCustomDataObject *result;
28154
28155 if(!PyArg_ParseTuple(args,(char *)":new_CustomDataObject")) goto fail;
28156 {
28157 PyThreadState* __tstate = wxPyBeginAllowThreads();
28158 result = (wxCustomDataObject *)new wxCustomDataObject();
28159
28160 wxPyEndAllowThreads(__tstate);
28161 if (PyErr_Occurred()) SWIG_fail;
28162 }
28163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCustomDataObject, 1);
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 static PyObject *_wrap_new_CustomDataObject(PyObject *self, PyObject *args) {
28171 int argc;
28172 PyObject *argv[2];
28173 int ii;
28174
28175 argc = PyObject_Length(args);
28176 for (ii = 0; (ii < argc) && (ii < 1); ii++) {
28177 argv[ii] = PyTuple_GetItem(args,ii);
28178 }
28179 if (argc == 0) {
28180 return _wrap_new_CustomDataObject__SWIG_2(self,args);
28181 }
28182 if (argc == 1) {
28183 int _v;
28184 {
28185 _v = PyString_Check(argv[0]) || PyUnicode_Check(argv[0]);
28186 }
28187 if (_v) {
28188 return _wrap_new_CustomDataObject__SWIG_1(self,args);
28189 }
28190 }
28191 if (argc == 1) {
28192 int _v;
28193 {
28194 void *ptr = 0;
28195 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxDataFormat, 0) == -1) {
28196 _v = 0;
28197 PyErr_Clear();
28198 } else {
28199 _v = (ptr != 0);
28200 }
28201 }
28202 if (_v) {
28203 return _wrap_new_CustomDataObject__SWIG_0(self,args);
28204 }
28205 }
28206
28207 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'new_CustomDataObject'");
28208 return NULL;
28209 }
28210
28211
28212 static PyObject *_wrap_CustomDataObject_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj;
28214 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28215 PyObject *arg2 = (PyObject *) 0 ;
28216 bool result;
28217 PyObject * obj0 = 0 ;
28218 PyObject * obj1 = 0 ;
28219 char *kwnames[] = {
28220 (char *) "self",(char *) "data", NULL
28221 };
28222
28223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CustomDataObject_SetData",kwnames,&obj0,&obj1)) 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 arg2 = obj1;
28227 {
28228 PyThreadState* __tstate = wxPyBeginAllowThreads();
28229 result = (bool)wxCustomDataObject_SetData(arg1,arg2);
28230
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 {
28235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28236 }
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 static PyObject *_wrap_CustomDataObject_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
28244 PyObject *resultobj;
28245 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28246 size_t result;
28247 PyObject * obj0 = 0 ;
28248 char *kwnames[] = {
28249 (char *) "self", NULL
28250 };
28251
28252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetSize",kwnames,&obj0)) goto fail;
28253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28254 if (SWIG_arg_fail(1)) SWIG_fail;
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = (size_t)(arg1)->GetSize();
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 {
28263 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
28264 }
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_CustomDataObject_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj;
28273 wxCustomDataObject *arg1 = (wxCustomDataObject *) 0 ;
28274 PyObject *result;
28275 PyObject * obj0 = 0 ;
28276 char *kwnames[] = {
28277 (char *) "self", NULL
28278 };
28279
28280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CustomDataObject_GetData",kwnames,&obj0)) goto fail;
28281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCustomDataObject, SWIG_POINTER_EXCEPTION | 0);
28282 if (SWIG_arg_fail(1)) SWIG_fail;
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 result = (PyObject *)wxCustomDataObject_GetData(arg1);
28286
28287 wxPyEndAllowThreads(__tstate);
28288 if (PyErr_Occurred()) SWIG_fail;
28289 }
28290 resultobj = result;
28291 return resultobj;
28292 fail:
28293 return NULL;
28294 }
28295
28296
28297 static PyObject * CustomDataObject_swigregister(PyObject *, PyObject *args) {
28298 PyObject *obj;
28299 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28300 SWIG_TypeClientData(SWIGTYPE_p_wxCustomDataObject, obj);
28301 Py_INCREF(obj);
28302 return Py_BuildValue((char *)"");
28303 }
28304 static PyObject *_wrap_new_URLDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj;
28306 wxURLDataObject *result;
28307 char *kwnames[] = {
28308 NULL
28309 };
28310
28311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_URLDataObject",kwnames)) goto fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (wxURLDataObject *)new wxURLDataObject();
28315
28316 wxPyEndAllowThreads(__tstate);
28317 if (PyErr_Occurred()) SWIG_fail;
28318 }
28319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxURLDataObject, 1);
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_URLDataObject_GetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj;
28328 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28329 wxString result;
28330 PyObject * obj0 = 0 ;
28331 char *kwnames[] = {
28332 (char *) "self", NULL
28333 };
28334
28335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:URLDataObject_GetURL",kwnames,&obj0)) goto fail;
28336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28337 if (SWIG_arg_fail(1)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (arg1)->GetURL();
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 {
28346 #if wxUSE_UNICODE
28347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28348 #else
28349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28350 #endif
28351 }
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 static PyObject *_wrap_URLDataObject_SetURL(PyObject *, PyObject *args, PyObject *kwargs) {
28359 PyObject *resultobj;
28360 wxURLDataObject *arg1 = (wxURLDataObject *) 0 ;
28361 wxString *arg2 = 0 ;
28362 bool temp2 = false ;
28363 PyObject * obj0 = 0 ;
28364 PyObject * obj1 = 0 ;
28365 char *kwnames[] = {
28366 (char *) "self",(char *) "url", NULL
28367 };
28368
28369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:URLDataObject_SetURL",kwnames,&obj0,&obj1)) goto fail;
28370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxURLDataObject, SWIG_POINTER_EXCEPTION | 0);
28371 if (SWIG_arg_fail(1)) SWIG_fail;
28372 {
28373 arg2 = wxString_in_helper(obj1);
28374 if (arg2 == NULL) SWIG_fail;
28375 temp2 = true;
28376 }
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 (arg1)->SetURL((wxString const &)*arg2);
28380
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 Py_INCREF(Py_None); resultobj = Py_None;
28385 {
28386 if (temp2)
28387 delete arg2;
28388 }
28389 return resultobj;
28390 fail:
28391 {
28392 if (temp2)
28393 delete arg2;
28394 }
28395 return NULL;
28396 }
28397
28398
28399 static PyObject * URLDataObject_swigregister(PyObject *, PyObject *args) {
28400 PyObject *obj;
28401 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28402 SWIG_TypeClientData(SWIGTYPE_p_wxURLDataObject, obj);
28403 Py_INCREF(obj);
28404 return Py_BuildValue((char *)"");
28405 }
28406 static PyObject *_wrap_new_MetafileDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28407 PyObject *resultobj;
28408 wxMetafileDataObject *result;
28409 char *kwnames[] = {
28410 NULL
28411 };
28412
28413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MetafileDataObject",kwnames)) goto fail;
28414 {
28415 PyThreadState* __tstate = wxPyBeginAllowThreads();
28416 result = (wxMetafileDataObject *)new wxMetafileDataObject();
28417
28418 wxPyEndAllowThreads(__tstate);
28419 if (PyErr_Occurred()) SWIG_fail;
28420 }
28421 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMetafileDataObject, 1);
28422 return resultobj;
28423 fail:
28424 return NULL;
28425 }
28426
28427
28428 static PyObject *_wrap_MetafileDataObject_SetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28429 PyObject *resultobj;
28430 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28431 wxMetafile *arg2 = 0 ;
28432 PyObject * obj0 = 0 ;
28433 PyObject * obj1 = 0 ;
28434 char *kwnames[] = {
28435 (char *) "self",(char *) "metafile", NULL
28436 };
28437
28438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MetafileDataObject_SetMetafile",kwnames,&obj0,&obj1)) goto fail;
28439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28440 if (SWIG_arg_fail(1)) SWIG_fail;
28441 {
28442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMetafile, SWIG_POINTER_EXCEPTION | 0);
28443 if (SWIG_arg_fail(2)) SWIG_fail;
28444 if (arg2 == NULL) {
28445 SWIG_null_ref("wxMetafile");
28446 }
28447 if (SWIG_arg_fail(2)) SWIG_fail;
28448 }
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 (arg1)->SetMetafile((wxMetafile const &)*arg2);
28452
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 Py_INCREF(Py_None); resultobj = Py_None;
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 static PyObject *_wrap_MetafileDataObject_GetMetafile(PyObject *, PyObject *args, PyObject *kwargs) {
28464 PyObject *resultobj;
28465 wxMetafileDataObject *arg1 = (wxMetafileDataObject *) 0 ;
28466 wxMetafile result;
28467 PyObject * obj0 = 0 ;
28468 char *kwnames[] = {
28469 (char *) "self", NULL
28470 };
28471
28472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MetafileDataObject_GetMetafile",kwnames,&obj0)) goto fail;
28473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMetafileDataObject, SWIG_POINTER_EXCEPTION | 0);
28474 if (SWIG_arg_fail(1)) SWIG_fail;
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = ((wxMetafileDataObject const *)arg1)->GetMetafile();
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 {
28483 wxMetafile * resultptr;
28484 resultptr = new wxMetafile((wxMetafile &)(result));
28485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxMetafile, 1);
28486 }
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 static PyObject * MetafileDataObject_swigregister(PyObject *, PyObject *args) {
28494 PyObject *obj;
28495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28496 SWIG_TypeClientData(SWIGTYPE_p_wxMetafileDataObject, obj);
28497 Py_INCREF(obj);
28498 return Py_BuildValue((char *)"");
28499 }
28500 static PyObject *_wrap_IsDragResultOk(PyObject *, PyObject *args, PyObject *kwargs) {
28501 PyObject *resultobj;
28502 wxDragResult arg1 ;
28503 bool result;
28504 PyObject * obj0 = 0 ;
28505 char *kwnames[] = {
28506 (char *) "res", NULL
28507 };
28508
28509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IsDragResultOk",kwnames,&obj0)) goto fail;
28510 {
28511 arg1 = (wxDragResult)(SWIG_As_int(obj0));
28512 if (SWIG_arg_fail(1)) SWIG_fail;
28513 }
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 result = (bool)wxIsDragResultOk((wxDragResult )arg1);
28517
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 {
28522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28523 }
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 static PyObject *_wrap_new_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj;
28532 wxWindow *arg1 = (wxWindow *) 0 ;
28533 wxCursor const &arg2_defvalue = wxNullCursor ;
28534 wxCursor *arg2 = (wxCursor *) &arg2_defvalue ;
28535 wxCursor const &arg3_defvalue = wxNullCursor ;
28536 wxCursor *arg3 = (wxCursor *) &arg3_defvalue ;
28537 wxCursor const &arg4_defvalue = wxNullCursor ;
28538 wxCursor *arg4 = (wxCursor *) &arg4_defvalue ;
28539 wxPyDropSource *result;
28540 PyObject * obj0 = 0 ;
28541 PyObject * obj1 = 0 ;
28542 PyObject * obj2 = 0 ;
28543 PyObject * obj3 = 0 ;
28544 char *kwnames[] = {
28545 (char *) "win",(char *) "copy",(char *) "move",(char *) "none", NULL
28546 };
28547
28548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:new_DropSource",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28550 if (SWIG_arg_fail(1)) SWIG_fail;
28551 if (obj1) {
28552 {
28553 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28554 if (SWIG_arg_fail(2)) SWIG_fail;
28555 if (arg2 == NULL) {
28556 SWIG_null_ref("wxCursor");
28557 }
28558 if (SWIG_arg_fail(2)) SWIG_fail;
28559 }
28560 }
28561 if (obj2) {
28562 {
28563 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(3)) SWIG_fail;
28565 if (arg3 == NULL) {
28566 SWIG_null_ref("wxCursor");
28567 }
28568 if (SWIG_arg_fail(3)) SWIG_fail;
28569 }
28570 }
28571 if (obj3) {
28572 {
28573 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28574 if (SWIG_arg_fail(4)) SWIG_fail;
28575 if (arg4 == NULL) {
28576 SWIG_null_ref("wxCursor");
28577 }
28578 if (SWIG_arg_fail(4)) SWIG_fail;
28579 }
28580 }
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 result = (wxPyDropSource *)new wxPyDropSource(arg1,(wxCursor const &)*arg2,(wxCursor const &)*arg3,(wxCursor const &)*arg4);
28584
28585 wxPyEndAllowThreads(__tstate);
28586 if (PyErr_Occurred()) SWIG_fail;
28587 }
28588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropSource, 1);
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 static PyObject *_wrap_DropSource__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28596 PyObject *resultobj;
28597 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28598 PyObject *arg2 = (PyObject *) 0 ;
28599 PyObject *arg3 = (PyObject *) 0 ;
28600 int arg4 ;
28601 PyObject * obj0 = 0 ;
28602 PyObject * obj1 = 0 ;
28603 PyObject * obj2 = 0 ;
28604 PyObject * obj3 = 0 ;
28605 char *kwnames[] = {
28606 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
28607 };
28608
28609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropSource__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28611 if (SWIG_arg_fail(1)) SWIG_fail;
28612 arg2 = obj1;
28613 arg3 = obj2;
28614 {
28615 arg4 = (int)(SWIG_As_int(obj3));
28616 if (SWIG_arg_fail(4)) SWIG_fail;
28617 }
28618 {
28619 PyThreadState* __tstate = wxPyBeginAllowThreads();
28620 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
28621
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 Py_INCREF(Py_None); resultobj = Py_None;
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 static PyObject *_wrap_delete_DropSource(PyObject *, PyObject *args, PyObject *kwargs) {
28633 PyObject *resultobj;
28634 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28635 PyObject * obj0 = 0 ;
28636 char *kwnames[] = {
28637 (char *) "self", NULL
28638 };
28639
28640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropSource",kwnames,&obj0)) goto fail;
28641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28642 if (SWIG_arg_fail(1)) SWIG_fail;
28643 {
28644 PyThreadState* __tstate = wxPyBeginAllowThreads();
28645 delete arg1;
28646
28647 wxPyEndAllowThreads(__tstate);
28648 if (PyErr_Occurred()) SWIG_fail;
28649 }
28650 Py_INCREF(Py_None); resultobj = Py_None;
28651 return resultobj;
28652 fail:
28653 return NULL;
28654 }
28655
28656
28657 static PyObject *_wrap_DropSource_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
28658 PyObject *resultobj;
28659 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28660 wxDataObject *arg2 = 0 ;
28661 PyObject * obj0 = 0 ;
28662 PyObject * obj1 = 0 ;
28663 char *kwnames[] = {
28664 (char *) "self",(char *) "data", NULL
28665 };
28666
28667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_SetData",kwnames,&obj0,&obj1)) goto fail;
28668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28669 if (SWIG_arg_fail(1)) SWIG_fail;
28670 {
28671 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
28672 if (SWIG_arg_fail(2)) SWIG_fail;
28673 if (arg2 == NULL) {
28674 SWIG_null_ref("wxDataObject");
28675 }
28676 if (SWIG_arg_fail(2)) SWIG_fail;
28677 }
28678 {
28679 PyThreadState* __tstate = wxPyBeginAllowThreads();
28680 (arg1)->SetData(*arg2);
28681
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 Py_INCREF(Py_None); resultobj = Py_None;
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 static PyObject *_wrap_DropSource_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28693 PyObject *resultobj;
28694 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28695 wxDataObject *result;
28696 PyObject * obj0 = 0 ;
28697 char *kwnames[] = {
28698 (char *) "self", NULL
28699 };
28700
28701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropSource_GetDataObject",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
28706 result = (wxDataObject *)(arg1)->GetDataObject();
28707
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 static PyObject *_wrap_DropSource_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
28719 PyObject *resultobj;
28720 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28721 wxDragResult arg2 ;
28722 wxCursor *arg3 = 0 ;
28723 PyObject * obj0 = 0 ;
28724 PyObject * obj1 = 0 ;
28725 PyObject * obj2 = 0 ;
28726 char *kwnames[] = {
28727 (char *) "self",(char *) "res",(char *) "cursor", NULL
28728 };
28729
28730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropSource_SetCursor",kwnames,&obj0,&obj1,&obj2)) goto fail;
28731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28732 if (SWIG_arg_fail(1)) SWIG_fail;
28733 {
28734 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28735 if (SWIG_arg_fail(2)) SWIG_fail;
28736 }
28737 {
28738 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
28739 if (SWIG_arg_fail(3)) SWIG_fail;
28740 if (arg3 == NULL) {
28741 SWIG_null_ref("wxCursor");
28742 }
28743 if (SWIG_arg_fail(3)) SWIG_fail;
28744 }
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 (arg1)->SetCursor((wxDragResult )arg2,(wxCursor const &)*arg3);
28748
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 Py_INCREF(Py_None); resultobj = Py_None;
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject *_wrap_DropSource_DoDragDrop(PyObject *, PyObject *args, PyObject *kwargs) {
28760 PyObject *resultobj;
28761 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28762 int arg2 = (int) wxDrag_CopyOnly ;
28763 wxDragResult result;
28764 PyObject * obj0 = 0 ;
28765 PyObject * obj1 = 0 ;
28766 char *kwnames[] = {
28767 (char *) "self",(char *) "flags", NULL
28768 };
28769
28770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:DropSource_DoDragDrop",kwnames,&obj0,&obj1)) goto fail;
28771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28772 if (SWIG_arg_fail(1)) SWIG_fail;
28773 if (obj1) {
28774 {
28775 arg2 = (int)(SWIG_As_int(obj1));
28776 if (SWIG_arg_fail(2)) SWIG_fail;
28777 }
28778 }
28779 {
28780 PyThreadState* __tstate = wxPyBeginAllowThreads();
28781 result = (wxDragResult)(arg1)->DoDragDrop(arg2);
28782
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 resultobj = SWIG_From_int((result));
28787 return resultobj;
28788 fail:
28789 return NULL;
28790 }
28791
28792
28793 static PyObject *_wrap_DropSource_base_GiveFeedback(PyObject *, PyObject *args, PyObject *kwargs) {
28794 PyObject *resultobj;
28795 wxPyDropSource *arg1 = (wxPyDropSource *) 0 ;
28796 wxDragResult arg2 ;
28797 bool result;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 char *kwnames[] = {
28801 (char *) "self",(char *) "effect", NULL
28802 };
28803
28804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropSource_base_GiveFeedback",kwnames,&obj0,&obj1)) goto fail;
28805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropSource, SWIG_POINTER_EXCEPTION | 0);
28806 if (SWIG_arg_fail(1)) SWIG_fail;
28807 {
28808 arg2 = (wxDragResult)(SWIG_As_int(obj1));
28809 if (SWIG_arg_fail(2)) SWIG_fail;
28810 }
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)(arg1)->base_GiveFeedback((wxDragResult )arg2);
28814
28815 wxPyEndAllowThreads(__tstate);
28816 if (PyErr_Occurred()) SWIG_fail;
28817 }
28818 {
28819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28820 }
28821 return resultobj;
28822 fail:
28823 return NULL;
28824 }
28825
28826
28827 static PyObject * DropSource_swigregister(PyObject *, PyObject *args) {
28828 PyObject *obj;
28829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
28830 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropSource, obj);
28831 Py_INCREF(obj);
28832 return Py_BuildValue((char *)"");
28833 }
28834 static PyObject *_wrap_new_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28835 PyObject *resultobj;
28836 wxDataObject *arg1 = (wxDataObject *) NULL ;
28837 wxPyDropTarget *result;
28838 PyObject * obj0 = 0 ;
28839 char *kwnames[] = {
28840 (char *) "dataObject", NULL
28841 };
28842
28843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
28844 if (obj0) {
28845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28846 if (SWIG_arg_fail(1)) SWIG_fail;
28847 }
28848 {
28849 PyThreadState* __tstate = wxPyBeginAllowThreads();
28850 result = (wxPyDropTarget *)new wxPyDropTarget(arg1);
28851
28852 wxPyEndAllowThreads(__tstate);
28853 if (PyErr_Occurred()) SWIG_fail;
28854 }
28855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 1);
28856 return resultobj;
28857 fail:
28858 return NULL;
28859 }
28860
28861
28862 static PyObject *_wrap_DropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
28863 PyObject *resultobj;
28864 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28865 PyObject *arg2 = (PyObject *) 0 ;
28866 PyObject *arg3 = (PyObject *) 0 ;
28867 PyObject * obj0 = 0 ;
28868 PyObject * obj1 = 0 ;
28869 PyObject * obj2 = 0 ;
28870 char *kwnames[] = {
28871 (char *) "self",(char *) "self",(char *) "_class", NULL
28872 };
28873
28874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
28875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28876 if (SWIG_arg_fail(1)) SWIG_fail;
28877 arg2 = obj1;
28878 arg3 = obj2;
28879 {
28880 PyThreadState* __tstate = wxPyBeginAllowThreads();
28881 (arg1)->_setCallbackInfo(arg2,arg3);
28882
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 Py_INCREF(Py_None); resultobj = Py_None;
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 static PyObject *_wrap_delete_DropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
28894 PyObject *resultobj;
28895 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28896 PyObject * obj0 = 0 ;
28897 char *kwnames[] = {
28898 (char *) "self", NULL
28899 };
28900
28901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_DropTarget",kwnames,&obj0)) goto fail;
28902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28903 if (SWIG_arg_fail(1)) SWIG_fail;
28904 {
28905 PyThreadState* __tstate = wxPyBeginAllowThreads();
28906 delete arg1;
28907
28908 wxPyEndAllowThreads(__tstate);
28909 if (PyErr_Occurred()) SWIG_fail;
28910 }
28911 Py_INCREF(Py_None); resultobj = Py_None;
28912 return resultobj;
28913 fail:
28914 return NULL;
28915 }
28916
28917
28918 static PyObject *_wrap_DropTarget_GetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28919 PyObject *resultobj;
28920 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28921 wxDataObject *result;
28922 PyObject * obj0 = 0 ;
28923 char *kwnames[] = {
28924 (char *) "self", NULL
28925 };
28926
28927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetDataObject",kwnames,&obj0)) goto fail;
28928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28929 if (SWIG_arg_fail(1)) SWIG_fail;
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxDataObject *)(arg1)->GetDataObject();
28933
28934 wxPyEndAllowThreads(__tstate);
28935 if (PyErr_Occurred()) SWIG_fail;
28936 }
28937 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDataObject, 0);
28938 return resultobj;
28939 fail:
28940 return NULL;
28941 }
28942
28943
28944 static PyObject *_wrap_DropTarget_SetDataObject(PyObject *, PyObject *args, PyObject *kwargs) {
28945 PyObject *resultobj;
28946 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28947 wxDataObject *arg2 = (wxDataObject *) 0 ;
28948 PyObject * obj0 = 0 ;
28949 PyObject * obj1 = 0 ;
28950 char *kwnames[] = {
28951 (char *) "self",(char *) "dataObject", NULL
28952 };
28953
28954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DropTarget_SetDataObject",kwnames,&obj0,&obj1)) goto fail;
28955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28956 if (SWIG_arg_fail(1)) SWIG_fail;
28957 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
28958 if (SWIG_arg_fail(2)) SWIG_fail;
28959 {
28960 PyThreadState* __tstate = wxPyBeginAllowThreads();
28961 (arg1)->SetDataObject(arg2);
28962
28963 wxPyEndAllowThreads(__tstate);
28964 if (PyErr_Occurred()) SWIG_fail;
28965 }
28966 Py_INCREF(Py_None); resultobj = Py_None;
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 static PyObject *_wrap_DropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
28974 PyObject *resultobj;
28975 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
28976 int arg2 ;
28977 int arg3 ;
28978 wxDragResult arg4 ;
28979 wxDragResult result;
28980 PyObject * obj0 = 0 ;
28981 PyObject * obj1 = 0 ;
28982 PyObject * obj2 = 0 ;
28983 PyObject * obj3 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 arg2 = (int)(SWIG_As_int(obj1));
28993 if (SWIG_arg_fail(2)) SWIG_fail;
28994 }
28995 {
28996 arg3 = (int)(SWIG_As_int(obj2));
28997 if (SWIG_arg_fail(3)) SWIG_fail;
28998 }
28999 {
29000 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29001 if (SWIG_arg_fail(4)) SWIG_fail;
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29006
29007 wxPyEndAllowThreads(__tstate);
29008 if (PyErr_Occurred()) SWIG_fail;
29009 }
29010 resultobj = SWIG_From_int((result));
29011 return resultobj;
29012 fail:
29013 return NULL;
29014 }
29015
29016
29017 static PyObject *_wrap_DropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29018 PyObject *resultobj;
29019 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29020 int arg2 ;
29021 int arg3 ;
29022 wxDragResult arg4 ;
29023 wxDragResult result;
29024 PyObject * obj0 = 0 ;
29025 PyObject * obj1 = 0 ;
29026 PyObject * obj2 = 0 ;
29027 PyObject * obj3 = 0 ;
29028 char *kwnames[] = {
29029 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29030 };
29031
29032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:DropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29034 if (SWIG_arg_fail(1)) SWIG_fail;
29035 {
29036 arg2 = (int)(SWIG_As_int(obj1));
29037 if (SWIG_arg_fail(2)) SWIG_fail;
29038 }
29039 {
29040 arg3 = (int)(SWIG_As_int(obj2));
29041 if (SWIG_arg_fail(3)) SWIG_fail;
29042 }
29043 {
29044 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29045 if (SWIG_arg_fail(4)) SWIG_fail;
29046 }
29047 {
29048 PyThreadState* __tstate = wxPyBeginAllowThreads();
29049 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29050
29051 wxPyEndAllowThreads(__tstate);
29052 if (PyErr_Occurred()) SWIG_fail;
29053 }
29054 resultobj = SWIG_From_int((result));
29055 return resultobj;
29056 fail:
29057 return NULL;
29058 }
29059
29060
29061 static PyObject *_wrap_DropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29062 PyObject *resultobj;
29063 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29064 PyObject * obj0 = 0 ;
29065 char *kwnames[] = {
29066 (char *) "self", NULL
29067 };
29068
29069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29071 if (SWIG_arg_fail(1)) SWIG_fail;
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 (arg1)->base_OnLeave();
29075
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 Py_INCREF(Py_None); resultobj = Py_None;
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 static PyObject *_wrap_DropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29087 PyObject *resultobj;
29088 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29089 int arg2 ;
29090 int arg3 ;
29091 bool result;
29092 PyObject * obj0 = 0 ;
29093 PyObject * obj1 = 0 ;
29094 PyObject * obj2 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self",(char *) "x",(char *) "y", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:DropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 arg2 = (int)(SWIG_As_int(obj1));
29104 if (SWIG_arg_fail(2)) SWIG_fail;
29105 }
29106 {
29107 arg3 = (int)(SWIG_As_int(obj2));
29108 if (SWIG_arg_fail(3)) SWIG_fail;
29109 }
29110 {
29111 PyThreadState* __tstate = wxPyBeginAllowThreads();
29112 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29113
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 {
29118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 static PyObject *_wrap_DropTarget_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29127 PyObject *resultobj;
29128 wxPyDropTarget *arg1 = (wxPyDropTarget *) 0 ;
29129 bool result;
29130 PyObject * obj0 = 0 ;
29131 char *kwnames[] = {
29132 (char *) "self", NULL
29133 };
29134
29135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropTarget_GetData",kwnames,&obj0)) goto fail;
29136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | 0);
29137 if (SWIG_arg_fail(1)) SWIG_fail;
29138 {
29139 PyThreadState* __tstate = wxPyBeginAllowThreads();
29140 result = (bool)(arg1)->GetData();
29141
29142 wxPyEndAllowThreads(__tstate);
29143 if (PyErr_Occurred()) SWIG_fail;
29144 }
29145 {
29146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29147 }
29148 return resultobj;
29149 fail:
29150 return NULL;
29151 }
29152
29153
29154 static PyObject * DropTarget_swigregister(PyObject *, PyObject *args) {
29155 PyObject *obj;
29156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29157 SWIG_TypeClientData(SWIGTYPE_p_wxPyDropTarget, obj);
29158 Py_INCREF(obj);
29159 return Py_BuildValue((char *)"");
29160 }
29161 static PyObject *_wrap_new_TextDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29162 PyObject *resultobj;
29163 wxPyTextDropTarget *result;
29164 char *kwnames[] = {
29165 NULL
29166 };
29167
29168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TextDropTarget",kwnames)) goto fail;
29169 {
29170 PyThreadState* __tstate = wxPyBeginAllowThreads();
29171 result = (wxPyTextDropTarget *)new wxPyTextDropTarget();
29172
29173 wxPyEndAllowThreads(__tstate);
29174 if (PyErr_Occurred()) SWIG_fail;
29175 }
29176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyTextDropTarget, 1);
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 static PyObject *_wrap_TextDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj;
29185 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29186 PyObject *arg2 = (PyObject *) 0 ;
29187 PyObject *arg3 = (PyObject *) 0 ;
29188 PyObject * obj0 = 0 ;
29189 PyObject * obj1 = 0 ;
29190 PyObject * obj2 = 0 ;
29191 char *kwnames[] = {
29192 (char *) "self",(char *) "self",(char *) "_class", NULL
29193 };
29194
29195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29197 if (SWIG_arg_fail(1)) SWIG_fail;
29198 arg2 = obj1;
29199 arg3 = obj2;
29200 {
29201 PyThreadState* __tstate = wxPyBeginAllowThreads();
29202 (arg1)->_setCallbackInfo(arg2,arg3);
29203
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 Py_INCREF(Py_None); resultobj = Py_None;
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 static PyObject *_wrap_TextDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj;
29216 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29217 int arg2 ;
29218 int arg3 ;
29219 wxDragResult arg4 ;
29220 wxDragResult result;
29221 PyObject * obj0 = 0 ;
29222 PyObject * obj1 = 0 ;
29223 PyObject * obj2 = 0 ;
29224 PyObject * obj3 = 0 ;
29225 char *kwnames[] = {
29226 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29227 };
29228
29229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29231 if (SWIG_arg_fail(1)) SWIG_fail;
29232 {
29233 arg2 = (int)(SWIG_As_int(obj1));
29234 if (SWIG_arg_fail(2)) SWIG_fail;
29235 }
29236 {
29237 arg3 = (int)(SWIG_As_int(obj2));
29238 if (SWIG_arg_fail(3)) SWIG_fail;
29239 }
29240 {
29241 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29242 if (SWIG_arg_fail(4)) SWIG_fail;
29243 }
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29247
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_From_int((result));
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 static PyObject *_wrap_TextDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj;
29260 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29261 int arg2 ;
29262 int arg3 ;
29263 wxDragResult arg4 ;
29264 wxDragResult result;
29265 PyObject * obj0 = 0 ;
29266 PyObject * obj1 = 0 ;
29267 PyObject * obj2 = 0 ;
29268 PyObject * obj3 = 0 ;
29269 char *kwnames[] = {
29270 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29271 };
29272
29273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29275 if (SWIG_arg_fail(1)) SWIG_fail;
29276 {
29277 arg2 = (int)(SWIG_As_int(obj1));
29278 if (SWIG_arg_fail(2)) SWIG_fail;
29279 }
29280 {
29281 arg3 = (int)(SWIG_As_int(obj2));
29282 if (SWIG_arg_fail(3)) SWIG_fail;
29283 }
29284 {
29285 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29286 if (SWIG_arg_fail(4)) SWIG_fail;
29287 }
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29291
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 resultobj = SWIG_From_int((result));
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 static PyObject *_wrap_TextDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29303 PyObject *resultobj;
29304 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29305 PyObject * obj0 = 0 ;
29306 char *kwnames[] = {
29307 (char *) "self", NULL
29308 };
29309
29310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:TextDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29312 if (SWIG_arg_fail(1)) SWIG_fail;
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 (arg1)->base_OnLeave();
29316
29317 wxPyEndAllowThreads(__tstate);
29318 if (PyErr_Occurred()) SWIG_fail;
29319 }
29320 Py_INCREF(Py_None); resultobj = Py_None;
29321 return resultobj;
29322 fail:
29323 return NULL;
29324 }
29325
29326
29327 static PyObject *_wrap_TextDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29328 PyObject *resultobj;
29329 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29330 int arg2 ;
29331 int arg3 ;
29332 bool result;
29333 PyObject * obj0 = 0 ;
29334 PyObject * obj1 = 0 ;
29335 PyObject * obj2 = 0 ;
29336 char *kwnames[] = {
29337 (char *) "self",(char *) "x",(char *) "y", NULL
29338 };
29339
29340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:TextDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29342 if (SWIG_arg_fail(1)) SWIG_fail;
29343 {
29344 arg2 = (int)(SWIG_As_int(obj1));
29345 if (SWIG_arg_fail(2)) SWIG_fail;
29346 }
29347 {
29348 arg3 = (int)(SWIG_As_int(obj2));
29349 if (SWIG_arg_fail(3)) SWIG_fail;
29350 }
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29354
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 {
29359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29360 }
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 static PyObject *_wrap_TextDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj;
29369 wxPyTextDropTarget *arg1 = (wxPyTextDropTarget *) 0 ;
29370 int arg2 ;
29371 int arg3 ;
29372 wxDragResult arg4 ;
29373 wxDragResult result;
29374 PyObject * obj0 = 0 ;
29375 PyObject * obj1 = 0 ;
29376 PyObject * obj2 = 0 ;
29377 PyObject * obj3 = 0 ;
29378 char *kwnames[] = {
29379 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29380 };
29381
29382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:TextDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyTextDropTarget, SWIG_POINTER_EXCEPTION | 0);
29384 if (SWIG_arg_fail(1)) SWIG_fail;
29385 {
29386 arg2 = (int)(SWIG_As_int(obj1));
29387 if (SWIG_arg_fail(2)) SWIG_fail;
29388 }
29389 {
29390 arg3 = (int)(SWIG_As_int(obj2));
29391 if (SWIG_arg_fail(3)) SWIG_fail;
29392 }
29393 {
29394 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29395 if (SWIG_arg_fail(4)) SWIG_fail;
29396 }
29397 {
29398 PyThreadState* __tstate = wxPyBeginAllowThreads();
29399 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29400
29401 wxPyEndAllowThreads(__tstate);
29402 if (PyErr_Occurred()) SWIG_fail;
29403 }
29404 resultobj = SWIG_From_int((result));
29405 return resultobj;
29406 fail:
29407 return NULL;
29408 }
29409
29410
29411 static PyObject * TextDropTarget_swigregister(PyObject *, PyObject *args) {
29412 PyObject *obj;
29413 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29414 SWIG_TypeClientData(SWIGTYPE_p_wxPyTextDropTarget, obj);
29415 Py_INCREF(obj);
29416 return Py_BuildValue((char *)"");
29417 }
29418 static PyObject *_wrap_new_FileDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj;
29420 wxPyFileDropTarget *result;
29421 char *kwnames[] = {
29422 NULL
29423 };
29424
29425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileDropTarget",kwnames)) goto fail;
29426 {
29427 PyThreadState* __tstate = wxPyBeginAllowThreads();
29428 result = (wxPyFileDropTarget *)new wxPyFileDropTarget();
29429
29430 wxPyEndAllowThreads(__tstate);
29431 if (PyErr_Occurred()) SWIG_fail;
29432 }
29433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileDropTarget, 1);
29434 return resultobj;
29435 fail:
29436 return NULL;
29437 }
29438
29439
29440 static PyObject *_wrap_FileDropTarget__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
29441 PyObject *resultobj;
29442 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29443 PyObject *arg2 = (PyObject *) 0 ;
29444 PyObject *arg3 = (PyObject *) 0 ;
29445 PyObject * obj0 = 0 ;
29446 PyObject * obj1 = 0 ;
29447 PyObject * obj2 = 0 ;
29448 char *kwnames[] = {
29449 (char *) "self",(char *) "self",(char *) "_class", NULL
29450 };
29451
29452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
29453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29454 if (SWIG_arg_fail(1)) SWIG_fail;
29455 arg2 = obj1;
29456 arg3 = obj2;
29457 {
29458 PyThreadState* __tstate = wxPyBeginAllowThreads();
29459 (arg1)->_setCallbackInfo(arg2,arg3);
29460
29461 wxPyEndAllowThreads(__tstate);
29462 if (PyErr_Occurred()) SWIG_fail;
29463 }
29464 Py_INCREF(Py_None); resultobj = Py_None;
29465 return resultobj;
29466 fail:
29467 return NULL;
29468 }
29469
29470
29471 static PyObject *_wrap_FileDropTarget_base_OnEnter(PyObject *, PyObject *args, PyObject *kwargs) {
29472 PyObject *resultobj;
29473 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29474 int arg2 ;
29475 int arg3 ;
29476 wxDragResult arg4 ;
29477 wxDragResult result;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 PyObject * obj2 = 0 ;
29481 PyObject * obj3 = 0 ;
29482 char *kwnames[] = {
29483 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29484 };
29485
29486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnEnter",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29488 if (SWIG_arg_fail(1)) SWIG_fail;
29489 {
29490 arg2 = (int)(SWIG_As_int(obj1));
29491 if (SWIG_arg_fail(2)) SWIG_fail;
29492 }
29493 {
29494 arg3 = (int)(SWIG_As_int(obj2));
29495 if (SWIG_arg_fail(3)) SWIG_fail;
29496 }
29497 {
29498 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29499 if (SWIG_arg_fail(4)) SWIG_fail;
29500 }
29501 {
29502 PyThreadState* __tstate = wxPyBeginAllowThreads();
29503 result = (wxDragResult)(arg1)->base_OnEnter(arg2,arg3,(wxDragResult )arg4);
29504
29505 wxPyEndAllowThreads(__tstate);
29506 if (PyErr_Occurred()) SWIG_fail;
29507 }
29508 resultobj = SWIG_From_int((result));
29509 return resultobj;
29510 fail:
29511 return NULL;
29512 }
29513
29514
29515 static PyObject *_wrap_FileDropTarget_base_OnDragOver(PyObject *, PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj;
29517 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29518 int arg2 ;
29519 int arg3 ;
29520 wxDragResult arg4 ;
29521 wxDragResult result;
29522 PyObject * obj0 = 0 ;
29523 PyObject * obj1 = 0 ;
29524 PyObject * obj2 = 0 ;
29525 PyObject * obj3 = 0 ;
29526 char *kwnames[] = {
29527 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29528 };
29529
29530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnDragOver",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29532 if (SWIG_arg_fail(1)) SWIG_fail;
29533 {
29534 arg2 = (int)(SWIG_As_int(obj1));
29535 if (SWIG_arg_fail(2)) SWIG_fail;
29536 }
29537 {
29538 arg3 = (int)(SWIG_As_int(obj2));
29539 if (SWIG_arg_fail(3)) SWIG_fail;
29540 }
29541 {
29542 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29543 if (SWIG_arg_fail(4)) SWIG_fail;
29544 }
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (wxDragResult)(arg1)->base_OnDragOver(arg2,arg3,(wxDragResult )arg4);
29548
29549 wxPyEndAllowThreads(__tstate);
29550 if (PyErr_Occurred()) SWIG_fail;
29551 }
29552 resultobj = SWIG_From_int((result));
29553 return resultobj;
29554 fail:
29555 return NULL;
29556 }
29557
29558
29559 static PyObject *_wrap_FileDropTarget_base_OnLeave(PyObject *, PyObject *args, PyObject *kwargs) {
29560 PyObject *resultobj;
29561 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29562 PyObject * obj0 = 0 ;
29563 char *kwnames[] = {
29564 (char *) "self", NULL
29565 };
29566
29567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileDropTarget_base_OnLeave",kwnames,&obj0)) goto fail;
29568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29569 if (SWIG_arg_fail(1)) SWIG_fail;
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 (arg1)->base_OnLeave();
29573
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 Py_INCREF(Py_None); resultobj = Py_None;
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 static PyObject *_wrap_FileDropTarget_base_OnDrop(PyObject *, PyObject *args, PyObject *kwargs) {
29585 PyObject *resultobj;
29586 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29587 int arg2 ;
29588 int arg3 ;
29589 bool result;
29590 PyObject * obj0 = 0 ;
29591 PyObject * obj1 = 0 ;
29592 PyObject * obj2 = 0 ;
29593 char *kwnames[] = {
29594 (char *) "self",(char *) "x",(char *) "y", NULL
29595 };
29596
29597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileDropTarget_base_OnDrop",kwnames,&obj0,&obj1,&obj2)) goto fail;
29598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29599 if (SWIG_arg_fail(1)) SWIG_fail;
29600 {
29601 arg2 = (int)(SWIG_As_int(obj1));
29602 if (SWIG_arg_fail(2)) SWIG_fail;
29603 }
29604 {
29605 arg3 = (int)(SWIG_As_int(obj2));
29606 if (SWIG_arg_fail(3)) SWIG_fail;
29607 }
29608 {
29609 PyThreadState* __tstate = wxPyBeginAllowThreads();
29610 result = (bool)(arg1)->base_OnDrop(arg2,arg3);
29611
29612 wxPyEndAllowThreads(__tstate);
29613 if (PyErr_Occurred()) SWIG_fail;
29614 }
29615 {
29616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29617 }
29618 return resultobj;
29619 fail:
29620 return NULL;
29621 }
29622
29623
29624 static PyObject *_wrap_FileDropTarget_base_OnData(PyObject *, PyObject *args, PyObject *kwargs) {
29625 PyObject *resultobj;
29626 wxPyFileDropTarget *arg1 = (wxPyFileDropTarget *) 0 ;
29627 int arg2 ;
29628 int arg3 ;
29629 wxDragResult arg4 ;
29630 wxDragResult result;
29631 PyObject * obj0 = 0 ;
29632 PyObject * obj1 = 0 ;
29633 PyObject * obj2 = 0 ;
29634 PyObject * obj3 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self",(char *) "x",(char *) "y",(char *) "def", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:FileDropTarget_base_OnData",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileDropTarget, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 arg2 = (int)(SWIG_As_int(obj1));
29644 if (SWIG_arg_fail(2)) SWIG_fail;
29645 }
29646 {
29647 arg3 = (int)(SWIG_As_int(obj2));
29648 if (SWIG_arg_fail(3)) SWIG_fail;
29649 }
29650 {
29651 arg4 = (wxDragResult)(SWIG_As_int(obj3));
29652 if (SWIG_arg_fail(4)) SWIG_fail;
29653 }
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = (wxDragResult)(arg1)->base_OnData(arg2,arg3,(wxDragResult )arg4);
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 resultobj = SWIG_From_int((result));
29662 return resultobj;
29663 fail:
29664 return NULL;
29665 }
29666
29667
29668 static PyObject * FileDropTarget_swigregister(PyObject *, PyObject *args) {
29669 PyObject *obj;
29670 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
29671 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileDropTarget, obj);
29672 Py_INCREF(obj);
29673 return Py_BuildValue((char *)"");
29674 }
29675 static PyObject *_wrap_new_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj;
29677 wxClipboard *result;
29678 char *kwnames[] = {
29679 NULL
29680 };
29681
29682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Clipboard",kwnames)) goto fail;
29683 {
29684 PyThreadState* __tstate = wxPyBeginAllowThreads();
29685 result = (wxClipboard *)new wxClipboard();
29686
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 1);
29691 return resultobj;
29692 fail:
29693 return NULL;
29694 }
29695
29696
29697 static PyObject *_wrap_delete_Clipboard(PyObject *, PyObject *args, PyObject *kwargs) {
29698 PyObject *resultobj;
29699 wxClipboard *arg1 = (wxClipboard *) 0 ;
29700 PyObject * obj0 = 0 ;
29701 char *kwnames[] = {
29702 (char *) "self", NULL
29703 };
29704
29705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Clipboard",kwnames,&obj0)) goto fail;
29706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29707 if (SWIG_arg_fail(1)) SWIG_fail;
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 delete arg1;
29711
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 Py_INCREF(Py_None); resultobj = Py_None;
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 static PyObject *_wrap_Clipboard_Open(PyObject *, PyObject *args, PyObject *kwargs) {
29723 PyObject *resultobj;
29724 wxClipboard *arg1 = (wxClipboard *) 0 ;
29725 bool result;
29726 PyObject * obj0 = 0 ;
29727 char *kwnames[] = {
29728 (char *) "self", NULL
29729 };
29730
29731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Open",kwnames,&obj0)) goto fail;
29732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29733 if (SWIG_arg_fail(1)) SWIG_fail;
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (bool)(arg1)->Open();
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 {
29742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29743 }
29744 return resultobj;
29745 fail:
29746 return NULL;
29747 }
29748
29749
29750 static PyObject *_wrap_Clipboard_Close(PyObject *, PyObject *args, PyObject *kwargs) {
29751 PyObject *resultobj;
29752 wxClipboard *arg1 = (wxClipboard *) 0 ;
29753 PyObject * obj0 = 0 ;
29754 char *kwnames[] = {
29755 (char *) "self", NULL
29756 };
29757
29758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Close",kwnames,&obj0)) goto fail;
29759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29760 if (SWIG_arg_fail(1)) SWIG_fail;
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 (arg1)->Close();
29764
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 Py_INCREF(Py_None); resultobj = Py_None;
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 static PyObject *_wrap_Clipboard_IsOpened(PyObject *, PyObject *args, PyObject *kwargs) {
29776 PyObject *resultobj;
29777 wxClipboard *arg1 = (wxClipboard *) 0 ;
29778 bool result;
29779 PyObject * obj0 = 0 ;
29780 char *kwnames[] = {
29781 (char *) "self", NULL
29782 };
29783
29784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_IsOpened",kwnames,&obj0)) goto fail;
29785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29786 if (SWIG_arg_fail(1)) SWIG_fail;
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (bool)((wxClipboard const *)arg1)->IsOpened();
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 {
29795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29796 }
29797 return resultobj;
29798 fail:
29799 return NULL;
29800 }
29801
29802
29803 static PyObject *_wrap_Clipboard_AddData(PyObject *, PyObject *args, PyObject *kwargs) {
29804 PyObject *resultobj;
29805 wxClipboard *arg1 = (wxClipboard *) 0 ;
29806 wxDataObject *arg2 = (wxDataObject *) 0 ;
29807 bool result;
29808 PyObject * obj0 = 0 ;
29809 PyObject * obj1 = 0 ;
29810 char *kwnames[] = {
29811 (char *) "self",(char *) "data", NULL
29812 };
29813
29814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_AddData",kwnames,&obj0,&obj1)) goto fail;
29815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29816 if (SWIG_arg_fail(1)) SWIG_fail;
29817 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29818 if (SWIG_arg_fail(2)) SWIG_fail;
29819 {
29820 PyThreadState* __tstate = wxPyBeginAllowThreads();
29821 result = (bool)(arg1)->AddData(arg2);
29822
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 {
29827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29828 }
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 static PyObject *_wrap_Clipboard_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
29836 PyObject *resultobj;
29837 wxClipboard *arg1 = (wxClipboard *) 0 ;
29838 wxDataObject *arg2 = (wxDataObject *) 0 ;
29839 bool result;
29840 PyObject * obj0 = 0 ;
29841 PyObject * obj1 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self",(char *) "data", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_SetData",kwnames,&obj0,&obj1)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
29850 if (SWIG_arg_fail(2)) SWIG_fail;
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = (bool)(arg1)->SetData(arg2);
29854
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 {
29859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29860 }
29861 return resultobj;
29862 fail:
29863 return NULL;
29864 }
29865
29866
29867 static PyObject *_wrap_Clipboard_IsSupported(PyObject *, PyObject *args, PyObject *kwargs) {
29868 PyObject *resultobj;
29869 wxClipboard *arg1 = (wxClipboard *) 0 ;
29870 wxDataFormat *arg2 = 0 ;
29871 bool result;
29872 PyObject * obj0 = 0 ;
29873 PyObject * obj1 = 0 ;
29874 char *kwnames[] = {
29875 (char *) "self",(char *) "format", NULL
29876 };
29877
29878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_IsSupported",kwnames,&obj0,&obj1)) goto fail;
29879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29880 if (SWIG_arg_fail(1)) SWIG_fail;
29881 {
29882 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataFormat, SWIG_POINTER_EXCEPTION | 0);
29883 if (SWIG_arg_fail(2)) SWIG_fail;
29884 if (arg2 == NULL) {
29885 SWIG_null_ref("wxDataFormat");
29886 }
29887 if (SWIG_arg_fail(2)) SWIG_fail;
29888 }
29889 {
29890 PyThreadState* __tstate = wxPyBeginAllowThreads();
29891 result = (bool)(arg1)->IsSupported((wxDataFormat const &)*arg2);
29892
29893 wxPyEndAllowThreads(__tstate);
29894 if (PyErr_Occurred()) SWIG_fail;
29895 }
29896 {
29897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29898 }
29899 return resultobj;
29900 fail:
29901 return NULL;
29902 }
29903
29904
29905 static PyObject *_wrap_Clipboard_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
29906 PyObject *resultobj;
29907 wxClipboard *arg1 = (wxClipboard *) 0 ;
29908 wxDataObject *arg2 = 0 ;
29909 bool result;
29910 PyObject * obj0 = 0 ;
29911 PyObject * obj1 = 0 ;
29912 char *kwnames[] = {
29913 (char *) "self",(char *) "data", NULL
29914 };
29915
29916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Clipboard_GetData",kwnames,&obj0,&obj1)) goto fail;
29917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29918 if (SWIG_arg_fail(1)) SWIG_fail;
29919 {
29920 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDataObject, SWIG_POINTER_EXCEPTION | 0);
29921 if (SWIG_arg_fail(2)) SWIG_fail;
29922 if (arg2 == NULL) {
29923 SWIG_null_ref("wxDataObject");
29924 }
29925 if (SWIG_arg_fail(2)) SWIG_fail;
29926 }
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (bool)(arg1)->GetData(*arg2);
29930
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 {
29935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29936 }
29937 return resultobj;
29938 fail:
29939 return NULL;
29940 }
29941
29942
29943 static PyObject *_wrap_Clipboard_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
29944 PyObject *resultobj;
29945 wxClipboard *arg1 = (wxClipboard *) 0 ;
29946 PyObject * obj0 = 0 ;
29947 char *kwnames[] = {
29948 (char *) "self", NULL
29949 };
29950
29951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Clear",kwnames,&obj0)) goto fail;
29952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
29953 if (SWIG_arg_fail(1)) SWIG_fail;
29954 {
29955 PyThreadState* __tstate = wxPyBeginAllowThreads();
29956 (arg1)->Clear();
29957
29958 wxPyEndAllowThreads(__tstate);
29959 if (PyErr_Occurred()) SWIG_fail;
29960 }
29961 Py_INCREF(Py_None); resultobj = Py_None;
29962 return resultobj;
29963 fail:
29964 return NULL;
29965 }
29966
29967
29968 static PyObject *_wrap_Clipboard_Flush(PyObject *, PyObject *args, PyObject *kwargs) {
29969 PyObject *resultobj;
29970 wxClipboard *arg1 = (wxClipboard *) 0 ;
29971 bool result;
29972 PyObject * obj0 = 0 ;
29973 char *kwnames[] = {
29974 (char *) "self", NULL
29975 };
29976
29977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Clipboard_Flush",kwnames,&obj0)) 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 {
29981 PyThreadState* __tstate = wxPyBeginAllowThreads();
29982 result = (bool)(arg1)->Flush();
29983
29984 wxPyEndAllowThreads(__tstate);
29985 if (PyErr_Occurred()) SWIG_fail;
29986 }
29987 {
29988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29989 }
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 static PyObject *_wrap_Clipboard_UsePrimarySelection(PyObject *, PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj;
29998 wxClipboard *arg1 = (wxClipboard *) 0 ;
29999 bool arg2 = (bool) true ;
30000 PyObject * obj0 = 0 ;
30001 PyObject * obj1 = 0 ;
30002 char *kwnames[] = {
30003 (char *) "self",(char *) "primary", NULL
30004 };
30005
30006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Clipboard_UsePrimarySelection",kwnames,&obj0,&obj1)) goto fail;
30007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30008 if (SWIG_arg_fail(1)) SWIG_fail;
30009 if (obj1) {
30010 {
30011 arg2 = (bool)(SWIG_As_bool(obj1));
30012 if (SWIG_arg_fail(2)) SWIG_fail;
30013 }
30014 }
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 (arg1)->UsePrimarySelection(arg2);
30018
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 Py_INCREF(Py_None); resultobj = Py_None;
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 static PyObject *_wrap_Clipboard_Get(PyObject *, PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj;
30031 wxClipboard *result;
30032 char *kwnames[] = {
30033 NULL
30034 };
30035
30036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Clipboard_Get",kwnames)) goto fail;
30037 {
30038 PyThreadState* __tstate = wxPyBeginAllowThreads();
30039 result = (wxClipboard *)wxClipboard::Get();
30040
30041 wxPyEndAllowThreads(__tstate);
30042 if (PyErr_Occurred()) SWIG_fail;
30043 }
30044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboard, 0);
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 static PyObject * Clipboard_swigregister(PyObject *, PyObject *args) {
30052 PyObject *obj;
30053 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30054 SWIG_TypeClientData(SWIGTYPE_p_wxClipboard, obj);
30055 Py_INCREF(obj);
30056 return Py_BuildValue((char *)"");
30057 }
30058 static PyObject *_wrap_new_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj;
30060 wxClipboard *arg1 = (wxClipboard *) NULL ;
30061 wxClipboardLocker *result;
30062 PyObject * obj0 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "clipboard", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ClipboardLocker",kwnames,&obj0)) goto fail;
30068 if (obj0) {
30069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboard, SWIG_POINTER_EXCEPTION | 0);
30070 if (SWIG_arg_fail(1)) SWIG_fail;
30071 }
30072 {
30073 PyThreadState* __tstate = wxPyBeginAllowThreads();
30074 result = (wxClipboardLocker *)new wxClipboardLocker(arg1);
30075
30076 wxPyEndAllowThreads(__tstate);
30077 if (PyErr_Occurred()) SWIG_fail;
30078 }
30079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxClipboardLocker, 1);
30080 return resultobj;
30081 fail:
30082 return NULL;
30083 }
30084
30085
30086 static PyObject *_wrap_delete_ClipboardLocker(PyObject *, PyObject *args, PyObject *kwargs) {
30087 PyObject *resultobj;
30088 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30089 PyObject * obj0 = 0 ;
30090 char *kwnames[] = {
30091 (char *) "self", NULL
30092 };
30093
30094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_ClipboardLocker",kwnames,&obj0)) goto fail;
30095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30096 if (SWIG_arg_fail(1)) SWIG_fail;
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 delete arg1;
30100
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 Py_INCREF(Py_None); resultobj = Py_None;
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 static PyObject *_wrap_ClipboardLocker___nonzero__(PyObject *, PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj;
30113 wxClipboardLocker *arg1 = (wxClipboardLocker *) 0 ;
30114 bool result;
30115 PyObject * obj0 = 0 ;
30116 char *kwnames[] = {
30117 (char *) "self", NULL
30118 };
30119
30120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ClipboardLocker___nonzero__",kwnames,&obj0)) goto fail;
30121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxClipboardLocker, SWIG_POINTER_EXCEPTION | 0);
30122 if (SWIG_arg_fail(1)) SWIG_fail;
30123 {
30124 PyThreadState* __tstate = wxPyBeginAllowThreads();
30125 result = (bool)wxClipboardLocker___nonzero__(arg1);
30126
30127 wxPyEndAllowThreads(__tstate);
30128 if (PyErr_Occurred()) SWIG_fail;
30129 }
30130 {
30131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30132 }
30133 return resultobj;
30134 fail:
30135 return NULL;
30136 }
30137
30138
30139 static PyObject * ClipboardLocker_swigregister(PyObject *, PyObject *args) {
30140 PyObject *obj;
30141 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30142 SWIG_TypeClientData(SWIGTYPE_p_wxClipboardLocker, obj);
30143 Py_INCREF(obj);
30144 return Py_BuildValue((char *)"");
30145 }
30146 static PyObject *_wrap_new_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30147 PyObject *resultobj;
30148 int arg1 = (int) 0 ;
30149 int arg2 = (int) 0 ;
30150 int arg3 = (int) 0 ;
30151 int arg4 = (int) 0 ;
30152 wxVideoMode *result;
30153 PyObject * obj0 = 0 ;
30154 PyObject * obj1 = 0 ;
30155 PyObject * obj2 = 0 ;
30156 PyObject * obj3 = 0 ;
30157 char *kwnames[] = {
30158 (char *) "width",(char *) "height",(char *) "depth",(char *) "freq", NULL
30159 };
30160
30161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_VideoMode",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30162 if (obj0) {
30163 {
30164 arg1 = (int)(SWIG_As_int(obj0));
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 }
30167 }
30168 if (obj1) {
30169 {
30170 arg2 = (int)(SWIG_As_int(obj1));
30171 if (SWIG_arg_fail(2)) SWIG_fail;
30172 }
30173 }
30174 if (obj2) {
30175 {
30176 arg3 = (int)(SWIG_As_int(obj2));
30177 if (SWIG_arg_fail(3)) SWIG_fail;
30178 }
30179 }
30180 if (obj3) {
30181 {
30182 arg4 = (int)(SWIG_As_int(obj3));
30183 if (SWIG_arg_fail(4)) SWIG_fail;
30184 }
30185 }
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 result = (wxVideoMode *)new wxVideoMode(arg1,arg2,arg3,arg4);
30189
30190 wxPyEndAllowThreads(__tstate);
30191 if (PyErr_Occurred()) SWIG_fail;
30192 }
30193 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVideoMode, 1);
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 static PyObject *_wrap_delete_VideoMode(PyObject *, PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj;
30202 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30203 PyObject * obj0 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "self", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VideoMode",kwnames,&obj0)) goto fail;
30209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(1)) SWIG_fail;
30211 {
30212 PyThreadState* __tstate = wxPyBeginAllowThreads();
30213 delete arg1;
30214
30215 wxPyEndAllowThreads(__tstate);
30216 if (PyErr_Occurred()) SWIG_fail;
30217 }
30218 Py_INCREF(Py_None); resultobj = Py_None;
30219 return resultobj;
30220 fail:
30221 return NULL;
30222 }
30223
30224
30225 static PyObject *_wrap_VideoMode_Matches(PyObject *, PyObject *args, PyObject *kwargs) {
30226 PyObject *resultobj;
30227 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30228 wxVideoMode *arg2 = 0 ;
30229 bool result;
30230 PyObject * obj0 = 0 ;
30231 PyObject * obj1 = 0 ;
30232 char *kwnames[] = {
30233 (char *) "self",(char *) "other", NULL
30234 };
30235
30236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_Matches",kwnames,&obj0,&obj1)) goto fail;
30237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30238 if (SWIG_arg_fail(1)) SWIG_fail;
30239 {
30240 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30241 if (SWIG_arg_fail(2)) SWIG_fail;
30242 if (arg2 == NULL) {
30243 SWIG_null_ref("wxVideoMode");
30244 }
30245 if (SWIG_arg_fail(2)) SWIG_fail;
30246 }
30247 {
30248 PyThreadState* __tstate = wxPyBeginAllowThreads();
30249 result = (bool)((wxVideoMode const *)arg1)->Matches((wxVideoMode const &)*arg2);
30250
30251 wxPyEndAllowThreads(__tstate);
30252 if (PyErr_Occurred()) SWIG_fail;
30253 }
30254 {
30255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30256 }
30257 return resultobj;
30258 fail:
30259 return NULL;
30260 }
30261
30262
30263 static PyObject *_wrap_VideoMode_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30264 PyObject *resultobj;
30265 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30266 int result;
30267 PyObject * obj0 = 0 ;
30268 char *kwnames[] = {
30269 (char *) "self", NULL
30270 };
30271
30272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetWidth",kwnames,&obj0)) goto fail;
30273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30274 if (SWIG_arg_fail(1)) SWIG_fail;
30275 {
30276 PyThreadState* __tstate = wxPyBeginAllowThreads();
30277 result = (int)((wxVideoMode const *)arg1)->GetWidth();
30278
30279 wxPyEndAllowThreads(__tstate);
30280 if (PyErr_Occurred()) SWIG_fail;
30281 }
30282 {
30283 resultobj = SWIG_From_int((int)(result));
30284 }
30285 return resultobj;
30286 fail:
30287 return NULL;
30288 }
30289
30290
30291 static PyObject *_wrap_VideoMode_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30292 PyObject *resultobj;
30293 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30294 int result;
30295 PyObject * obj0 = 0 ;
30296 char *kwnames[] = {
30297 (char *) "self", NULL
30298 };
30299
30300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetHeight",kwnames,&obj0)) goto fail;
30301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30302 if (SWIG_arg_fail(1)) SWIG_fail;
30303 {
30304 PyThreadState* __tstate = wxPyBeginAllowThreads();
30305 result = (int)((wxVideoMode const *)arg1)->GetHeight();
30306
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 {
30311 resultobj = SWIG_From_int((int)(result));
30312 }
30313 return resultobj;
30314 fail:
30315 return NULL;
30316 }
30317
30318
30319 static PyObject *_wrap_VideoMode_GetDepth(PyObject *, PyObject *args, PyObject *kwargs) {
30320 PyObject *resultobj;
30321 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30322 int result;
30323 PyObject * obj0 = 0 ;
30324 char *kwnames[] = {
30325 (char *) "self", NULL
30326 };
30327
30328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_GetDepth",kwnames,&obj0)) goto fail;
30329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30330 if (SWIG_arg_fail(1)) SWIG_fail;
30331 {
30332 PyThreadState* __tstate = wxPyBeginAllowThreads();
30333 result = (int)((wxVideoMode const *)arg1)->GetDepth();
30334
30335 wxPyEndAllowThreads(__tstate);
30336 if (PyErr_Occurred()) SWIG_fail;
30337 }
30338 {
30339 resultobj = SWIG_From_int((int)(result));
30340 }
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 static PyObject *_wrap_VideoMode_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj;
30349 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30350 bool result;
30351 PyObject * obj0 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_IsOk",kwnames,&obj0)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 PyThreadState* __tstate = wxPyBeginAllowThreads();
30361 result = (bool)((wxVideoMode const *)arg1)->IsOk();
30362
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 {
30367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30368 }
30369 return resultobj;
30370 fail:
30371 return NULL;
30372 }
30373
30374
30375 static PyObject *_wrap_VideoMode___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
30376 PyObject *resultobj;
30377 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30378 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30379 bool result;
30380 PyObject * obj0 = 0 ;
30381 PyObject * obj1 = 0 ;
30382 char *kwnames[] = {
30383 (char *) "self",(char *) "other", NULL
30384 };
30385
30386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___eq__",kwnames,&obj0,&obj1)) goto fail;
30387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30388 if (SWIG_arg_fail(1)) SWIG_fail;
30389 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30390 if (SWIG_arg_fail(2)) SWIG_fail;
30391 {
30392 PyThreadState* __tstate = wxPyBeginAllowThreads();
30393 result = (bool)wxVideoMode___eq__(arg1,(wxVideoMode const *)arg2);
30394
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 {
30399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30400 }
30401 return resultobj;
30402 fail:
30403 return NULL;
30404 }
30405
30406
30407 static PyObject *_wrap_VideoMode___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
30408 PyObject *resultobj;
30409 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30410 wxVideoMode *arg2 = (wxVideoMode *) 0 ;
30411 bool result;
30412 PyObject * obj0 = 0 ;
30413 PyObject * obj1 = 0 ;
30414 char *kwnames[] = {
30415 (char *) "self",(char *) "other", NULL
30416 };
30417
30418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode___ne__",kwnames,&obj0,&obj1)) goto fail;
30419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30420 if (SWIG_arg_fail(1)) SWIG_fail;
30421 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30422 if (SWIG_arg_fail(2)) SWIG_fail;
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 result = (bool)wxVideoMode___ne__(arg1,(wxVideoMode const *)arg2);
30426
30427 wxPyEndAllowThreads(__tstate);
30428 if (PyErr_Occurred()) SWIG_fail;
30429 }
30430 {
30431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30432 }
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 static PyObject *_wrap_VideoMode_w_set(PyObject *, PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj;
30441 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30442 int arg2 ;
30443 PyObject * obj0 = 0 ;
30444 PyObject * obj1 = 0 ;
30445 char *kwnames[] = {
30446 (char *) "self",(char *) "w", NULL
30447 };
30448
30449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_w_set",kwnames,&obj0,&obj1)) goto fail;
30450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30451 if (SWIG_arg_fail(1)) SWIG_fail;
30452 {
30453 arg2 = (int)(SWIG_As_int(obj1));
30454 if (SWIG_arg_fail(2)) SWIG_fail;
30455 }
30456 if (arg1) (arg1)->w = arg2;
30457
30458 Py_INCREF(Py_None); resultobj = Py_None;
30459 return resultobj;
30460 fail:
30461 return NULL;
30462 }
30463
30464
30465 static PyObject *_wrap_VideoMode_w_get(PyObject *, PyObject *args, PyObject *kwargs) {
30466 PyObject *resultobj;
30467 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30468 int result;
30469 PyObject * obj0 = 0 ;
30470 char *kwnames[] = {
30471 (char *) "self", NULL
30472 };
30473
30474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_w_get",kwnames,&obj0)) goto fail;
30475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30476 if (SWIG_arg_fail(1)) SWIG_fail;
30477 result = (int) ((arg1)->w);
30478
30479 {
30480 resultobj = SWIG_From_int((int)(result));
30481 }
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_VideoMode_h_set(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30491 int arg2 ;
30492 PyObject * obj0 = 0 ;
30493 PyObject * obj1 = 0 ;
30494 char *kwnames[] = {
30495 (char *) "self",(char *) "h", NULL
30496 };
30497
30498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_h_set",kwnames,&obj0,&obj1)) goto fail;
30499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30500 if (SWIG_arg_fail(1)) SWIG_fail;
30501 {
30502 arg2 = (int)(SWIG_As_int(obj1));
30503 if (SWIG_arg_fail(2)) SWIG_fail;
30504 }
30505 if (arg1) (arg1)->h = arg2;
30506
30507 Py_INCREF(Py_None); resultobj = Py_None;
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_VideoMode_h_get(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj;
30516 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30517 int result;
30518 PyObject * obj0 = 0 ;
30519 char *kwnames[] = {
30520 (char *) "self", NULL
30521 };
30522
30523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_h_get",kwnames,&obj0)) goto fail;
30524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30525 if (SWIG_arg_fail(1)) SWIG_fail;
30526 result = (int) ((arg1)->h);
30527
30528 {
30529 resultobj = SWIG_From_int((int)(result));
30530 }
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 static PyObject *_wrap_VideoMode_bpp_set(PyObject *, PyObject *args, PyObject *kwargs) {
30538 PyObject *resultobj;
30539 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30540 int arg2 ;
30541 PyObject * obj0 = 0 ;
30542 PyObject * obj1 = 0 ;
30543 char *kwnames[] = {
30544 (char *) "self",(char *) "bpp", NULL
30545 };
30546
30547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_bpp_set",kwnames,&obj0,&obj1)) goto fail;
30548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30549 if (SWIG_arg_fail(1)) SWIG_fail;
30550 {
30551 arg2 = (int)(SWIG_As_int(obj1));
30552 if (SWIG_arg_fail(2)) SWIG_fail;
30553 }
30554 if (arg1) (arg1)->bpp = arg2;
30555
30556 Py_INCREF(Py_None); resultobj = Py_None;
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 static PyObject *_wrap_VideoMode_bpp_get(PyObject *, PyObject *args, PyObject *kwargs) {
30564 PyObject *resultobj;
30565 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30566 int result;
30567 PyObject * obj0 = 0 ;
30568 char *kwnames[] = {
30569 (char *) "self", NULL
30570 };
30571
30572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_bpp_get",kwnames,&obj0)) goto fail;
30573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30574 if (SWIG_arg_fail(1)) SWIG_fail;
30575 result = (int) ((arg1)->bpp);
30576
30577 {
30578 resultobj = SWIG_From_int((int)(result));
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 static PyObject *_wrap_VideoMode_refresh_set(PyObject *, PyObject *args, PyObject *kwargs) {
30587 PyObject *resultobj;
30588 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30589 int arg2 ;
30590 PyObject * obj0 = 0 ;
30591 PyObject * obj1 = 0 ;
30592 char *kwnames[] = {
30593 (char *) "self",(char *) "refresh", NULL
30594 };
30595
30596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VideoMode_refresh_set",kwnames,&obj0,&obj1)) goto fail;
30597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30598 if (SWIG_arg_fail(1)) SWIG_fail;
30599 {
30600 arg2 = (int)(SWIG_As_int(obj1));
30601 if (SWIG_arg_fail(2)) SWIG_fail;
30602 }
30603 if (arg1) (arg1)->refresh = arg2;
30604
30605 Py_INCREF(Py_None); resultobj = Py_None;
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 static PyObject *_wrap_VideoMode_refresh_get(PyObject *, PyObject *args, PyObject *kwargs) {
30613 PyObject *resultobj;
30614 wxVideoMode *arg1 = (wxVideoMode *) 0 ;
30615 int result;
30616 PyObject * obj0 = 0 ;
30617 char *kwnames[] = {
30618 (char *) "self", NULL
30619 };
30620
30621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VideoMode_refresh_get",kwnames,&obj0)) goto fail;
30622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30623 if (SWIG_arg_fail(1)) SWIG_fail;
30624 result = (int) ((arg1)->refresh);
30625
30626 {
30627 resultobj = SWIG_From_int((int)(result));
30628 }
30629 return resultobj;
30630 fail:
30631 return NULL;
30632 }
30633
30634
30635 static PyObject * VideoMode_swigregister(PyObject *, PyObject *args) {
30636 PyObject *obj;
30637 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
30638 SWIG_TypeClientData(SWIGTYPE_p_wxVideoMode, obj);
30639 Py_INCREF(obj);
30640 return Py_BuildValue((char *)"");
30641 }
30642 static int _wrap_DefaultVideoMode_set(PyObject *) {
30643 PyErr_SetString(PyExc_TypeError,"Variable DefaultVideoMode is read-only.");
30644 return 1;
30645 }
30646
30647
30648 static PyObject *_wrap_DefaultVideoMode_get(void) {
30649 PyObject *pyobj;
30650
30651 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultVideoMode), SWIGTYPE_p_wxVideoMode, 0);
30652 return pyobj;
30653 }
30654
30655
30656 static PyObject *_wrap_new_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30657 PyObject *resultobj;
30658 size_t arg1 = (size_t) 0 ;
30659 wxDisplay *result;
30660 PyObject * obj0 = 0 ;
30661 char *kwnames[] = {
30662 (char *) "index", NULL
30663 };
30664
30665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Display",kwnames,&obj0)) goto fail;
30666 if (obj0) {
30667 {
30668 arg1 = (size_t)(SWIG_As_unsigned_SS_long(obj0));
30669 if (SWIG_arg_fail(1)) SWIG_fail;
30670 }
30671 }
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (wxDisplay *)new wxDisplay(arg1);
30675
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplay, 1);
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 static PyObject *_wrap_delete_Display(PyObject *, PyObject *args, PyObject *kwargs) {
30687 PyObject *resultobj;
30688 wxDisplay *arg1 = (wxDisplay *) 0 ;
30689 PyObject * obj0 = 0 ;
30690 char *kwnames[] = {
30691 (char *) "self", NULL
30692 };
30693
30694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Display",kwnames,&obj0)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 delete arg1;
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 Py_INCREF(Py_None); resultobj = Py_None;
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 static PyObject *_wrap_Display_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
30712 PyObject *resultobj;
30713 size_t result;
30714 char *kwnames[] = {
30715 NULL
30716 };
30717
30718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Display_GetCount",kwnames)) goto fail;
30719 {
30720 PyThreadState* __tstate = wxPyBeginAllowThreads();
30721 result = (size_t)wxDisplay::GetCount();
30722
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 {
30727 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
30728 }
30729 return resultobj;
30730 fail:
30731 return NULL;
30732 }
30733
30734
30735 static PyObject *_wrap_Display_GetFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30736 PyObject *resultobj;
30737 wxPoint *arg1 = 0 ;
30738 int result;
30739 wxPoint temp1 ;
30740 PyObject * obj0 = 0 ;
30741 char *kwnames[] = {
30742 (char *) "pt", NULL
30743 };
30744
30745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromPoint",kwnames,&obj0)) goto fail;
30746 {
30747 arg1 = &temp1;
30748 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
30749 }
30750 {
30751 PyThreadState* __tstate = wxPyBeginAllowThreads();
30752 result = (int)wxDisplay::GetFromPoint((wxPoint const &)*arg1);
30753
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 {
30758 resultobj = SWIG_From_int((int)(result));
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 static PyObject *_wrap_Display_GetFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj;
30768 wxWindow *arg1 = (wxWindow *) 0 ;
30769 int result;
30770 PyObject * obj0 = 0 ;
30771 char *kwnames[] = {
30772 (char *) "window", NULL
30773 };
30774
30775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetFromWindow",kwnames,&obj0)) goto fail;
30776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30777 if (SWIG_arg_fail(1)) SWIG_fail;
30778 {
30779 PyThreadState* __tstate = wxPyBeginAllowThreads();
30780 result = (int)wxDisplay::GetFromWindow(arg1);
30781
30782 wxPyEndAllowThreads(__tstate);
30783 if (PyErr_Occurred()) SWIG_fail;
30784 }
30785 {
30786 resultobj = SWIG_From_int((int)(result));
30787 }
30788 return resultobj;
30789 fail:
30790 return NULL;
30791 }
30792
30793
30794 static PyObject *_wrap_Display_IsOk(PyObject *, PyObject *args, PyObject *kwargs) {
30795 PyObject *resultobj;
30796 wxDisplay *arg1 = (wxDisplay *) 0 ;
30797 bool result;
30798 PyObject * obj0 = 0 ;
30799 char *kwnames[] = {
30800 (char *) "self", NULL
30801 };
30802
30803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsOk",kwnames,&obj0)) goto fail;
30804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30805 if (SWIG_arg_fail(1)) SWIG_fail;
30806 {
30807 PyThreadState* __tstate = wxPyBeginAllowThreads();
30808 result = (bool)((wxDisplay const *)arg1)->IsOk();
30809
30810 wxPyEndAllowThreads(__tstate);
30811 if (PyErr_Occurred()) SWIG_fail;
30812 }
30813 {
30814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30815 }
30816 return resultobj;
30817 fail:
30818 return NULL;
30819 }
30820
30821
30822 static PyObject *_wrap_Display_GetGeometry(PyObject *, PyObject *args, PyObject *kwargs) {
30823 PyObject *resultobj;
30824 wxDisplay *arg1 = (wxDisplay *) 0 ;
30825 wxRect result;
30826 PyObject * obj0 = 0 ;
30827 char *kwnames[] = {
30828 (char *) "self", NULL
30829 };
30830
30831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetGeometry",kwnames,&obj0)) goto fail;
30832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(1)) SWIG_fail;
30834 {
30835 PyThreadState* __tstate = wxPyBeginAllowThreads();
30836 result = ((wxDisplay const *)arg1)->GetGeometry();
30837
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 {
30842 wxRect * resultptr;
30843 resultptr = new wxRect((wxRect &)(result));
30844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30845 }
30846 return resultobj;
30847 fail:
30848 return NULL;
30849 }
30850
30851
30852 static PyObject *_wrap_Display_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
30853 PyObject *resultobj;
30854 wxDisplay *arg1 = (wxDisplay *) 0 ;
30855 wxString result;
30856 PyObject * obj0 = 0 ;
30857 char *kwnames[] = {
30858 (char *) "self", NULL
30859 };
30860
30861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetName",kwnames,&obj0)) goto fail;
30862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30863 if (SWIG_arg_fail(1)) SWIG_fail;
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = ((wxDisplay const *)arg1)->GetName();
30867
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 {
30872 #if wxUSE_UNICODE
30873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30874 #else
30875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30876 #endif
30877 }
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 static PyObject *_wrap_Display_IsPrimary(PyObject *, PyObject *args, PyObject *kwargs) {
30885 PyObject *resultobj;
30886 wxDisplay *arg1 = (wxDisplay *) 0 ;
30887 bool result;
30888 PyObject * obj0 = 0 ;
30889 char *kwnames[] = {
30890 (char *) "self", NULL
30891 };
30892
30893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_IsPrimary",kwnames,&obj0)) goto fail;
30894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30895 if (SWIG_arg_fail(1)) SWIG_fail;
30896 {
30897 PyThreadState* __tstate = wxPyBeginAllowThreads();
30898 result = (bool)((wxDisplay const *)arg1)->IsPrimary();
30899
30900 wxPyEndAllowThreads(__tstate);
30901 if (PyErr_Occurred()) SWIG_fail;
30902 }
30903 {
30904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30905 }
30906 return resultobj;
30907 fail:
30908 return NULL;
30909 }
30910
30911
30912 static PyObject *_wrap_Display_GetModes(PyObject *, PyObject *args, PyObject *kwargs) {
30913 PyObject *resultobj;
30914 wxDisplay *arg1 = (wxDisplay *) 0 ;
30915 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30916 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30917 PyObject *result;
30918 PyObject * obj0 = 0 ;
30919 PyObject * obj1 = 0 ;
30920 char *kwnames[] = {
30921 (char *) "self",(char *) "mode", NULL
30922 };
30923
30924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_GetModes",kwnames,&obj0,&obj1)) goto fail;
30925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30926 if (SWIG_arg_fail(1)) SWIG_fail;
30927 if (obj1) {
30928 {
30929 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30930 if (SWIG_arg_fail(2)) SWIG_fail;
30931 if (arg2 == NULL) {
30932 SWIG_null_ref("wxVideoMode");
30933 }
30934 if (SWIG_arg_fail(2)) SWIG_fail;
30935 }
30936 }
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (PyObject *)wxDisplay_GetModes(arg1,(wxVideoMode const &)*arg2);
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 resultobj = result;
30945 return resultobj;
30946 fail:
30947 return NULL;
30948 }
30949
30950
30951 static PyObject *_wrap_Display_GetCurrentMode(PyObject *, PyObject *args, PyObject *kwargs) {
30952 PyObject *resultobj;
30953 wxDisplay *arg1 = (wxDisplay *) 0 ;
30954 wxVideoMode result;
30955 PyObject * obj0 = 0 ;
30956 char *kwnames[] = {
30957 (char *) "self", NULL
30958 };
30959
30960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_GetCurrentMode",kwnames,&obj0)) goto fail;
30961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30962 if (SWIG_arg_fail(1)) SWIG_fail;
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 result = ((wxDisplay const *)arg1)->GetCurrentMode();
30966
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 {
30971 wxVideoMode * resultptr;
30972 resultptr = new wxVideoMode((wxVideoMode &)(result));
30973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVideoMode, 1);
30974 }
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 static PyObject *_wrap_Display_ChangeMode(PyObject *, PyObject *args, PyObject *kwargs) {
30982 PyObject *resultobj;
30983 wxDisplay *arg1 = (wxDisplay *) 0 ;
30984 wxVideoMode const &arg2_defvalue = wxDefaultVideoMode ;
30985 wxVideoMode *arg2 = (wxVideoMode *) &arg2_defvalue ;
30986 bool result;
30987 PyObject * obj0 = 0 ;
30988 PyObject * obj1 = 0 ;
30989 char *kwnames[] = {
30990 (char *) "self",(char *) "mode", NULL
30991 };
30992
30993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Display_ChangeMode",kwnames,&obj0,&obj1)) goto fail;
30994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
30995 if (SWIG_arg_fail(1)) SWIG_fail;
30996 if (obj1) {
30997 {
30998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxVideoMode, SWIG_POINTER_EXCEPTION | 0);
30999 if (SWIG_arg_fail(2)) SWIG_fail;
31000 if (arg2 == NULL) {
31001 SWIG_null_ref("wxVideoMode");
31002 }
31003 if (SWIG_arg_fail(2)) SWIG_fail;
31004 }
31005 }
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = (bool)(arg1)->ChangeMode((wxVideoMode const &)*arg2);
31009
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 {
31014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31015 }
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 static PyObject *_wrap_Display_ResetMode(PyObject *, PyObject *args, PyObject *kwargs) {
31023 PyObject *resultobj;
31024 wxDisplay *arg1 = (wxDisplay *) 0 ;
31025 PyObject * obj0 = 0 ;
31026 char *kwnames[] = {
31027 (char *) "self", NULL
31028 };
31029
31030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Display_ResetMode",kwnames,&obj0)) goto fail;
31031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDisplay, SWIG_POINTER_EXCEPTION | 0);
31032 if (SWIG_arg_fail(1)) SWIG_fail;
31033 {
31034 PyThreadState* __tstate = wxPyBeginAllowThreads();
31035 (arg1)->ResetMode();
31036
31037 wxPyEndAllowThreads(__tstate);
31038 if (PyErr_Occurred()) SWIG_fail;
31039 }
31040 Py_INCREF(Py_None); resultobj = Py_None;
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 static PyObject * Display_swigregister(PyObject *, PyObject *args) {
31048 PyObject *obj;
31049 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31050 SWIG_TypeClientData(SWIGTYPE_p_wxDisplay, obj);
31051 Py_INCREF(obj);
31052 return Py_BuildValue((char *)"");
31053 }
31054 static PyObject *_wrap_StandardPaths_Get(PyObject *, PyObject *args, PyObject *kwargs) {
31055 PyObject *resultobj;
31056 wxStandardPaths *result;
31057 char *kwnames[] = {
31058 NULL
31059 };
31060
31061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":StandardPaths_Get",kwnames)) goto fail;
31062 {
31063 PyThreadState* __tstate = wxPyBeginAllowThreads();
31064 result = (wxStandardPaths *)StandardPaths_Get();
31065
31066 wxPyEndAllowThreads(__tstate);
31067 if (PyErr_Occurred()) SWIG_fail;
31068 }
31069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStandardPaths, 0);
31070 return resultobj;
31071 fail:
31072 return NULL;
31073 }
31074
31075
31076 static PyObject *_wrap_StandardPaths_GetConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31077 PyObject *resultobj;
31078 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31079 wxString result;
31080 PyObject * obj0 = 0 ;
31081 char *kwnames[] = {
31082 (char *) "self", NULL
31083 };
31084
31085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetConfigDir",kwnames,&obj0)) goto fail;
31086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31087 if (SWIG_arg_fail(1)) SWIG_fail;
31088 {
31089 PyThreadState* __tstate = wxPyBeginAllowThreads();
31090 result = ((wxStandardPaths const *)arg1)->GetConfigDir();
31091
31092 wxPyEndAllowThreads(__tstate);
31093 if (PyErr_Occurred()) SWIG_fail;
31094 }
31095 {
31096 #if wxUSE_UNICODE
31097 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31098 #else
31099 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31100 #endif
31101 }
31102 return resultobj;
31103 fail:
31104 return NULL;
31105 }
31106
31107
31108 static PyObject *_wrap_StandardPaths_GetUserConfigDir(PyObject *, PyObject *args, PyObject *kwargs) {
31109 PyObject *resultobj;
31110 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31111 wxString result;
31112 PyObject * obj0 = 0 ;
31113 char *kwnames[] = {
31114 (char *) "self", NULL
31115 };
31116
31117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserConfigDir",kwnames,&obj0)) goto fail;
31118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31119 if (SWIG_arg_fail(1)) SWIG_fail;
31120 {
31121 PyThreadState* __tstate = wxPyBeginAllowThreads();
31122 result = ((wxStandardPaths const *)arg1)->GetUserConfigDir();
31123
31124 wxPyEndAllowThreads(__tstate);
31125 if (PyErr_Occurred()) SWIG_fail;
31126 }
31127 {
31128 #if wxUSE_UNICODE
31129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31130 #else
31131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31132 #endif
31133 }
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 static PyObject *_wrap_StandardPaths_GetDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31141 PyObject *resultobj;
31142 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31143 wxString result;
31144 PyObject * obj0 = 0 ;
31145 char *kwnames[] = {
31146 (char *) "self", NULL
31147 };
31148
31149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetDataDir",kwnames,&obj0)) goto fail;
31150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31151 if (SWIG_arg_fail(1)) SWIG_fail;
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = ((wxStandardPaths const *)arg1)->GetDataDir();
31155
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 {
31160 #if wxUSE_UNICODE
31161 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31162 #else
31163 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31164 #endif
31165 }
31166 return resultobj;
31167 fail:
31168 return NULL;
31169 }
31170
31171
31172 static PyObject *_wrap_StandardPaths_GetLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31173 PyObject *resultobj;
31174 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31175 wxString result;
31176 PyObject * obj0 = 0 ;
31177 char *kwnames[] = {
31178 (char *) "self", NULL
31179 };
31180
31181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetLocalDataDir",kwnames,&obj0)) goto fail;
31182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31183 if (SWIG_arg_fail(1)) SWIG_fail;
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = ((wxStandardPaths const *)arg1)->GetLocalDataDir();
31187
31188 wxPyEndAllowThreads(__tstate);
31189 if (PyErr_Occurred()) SWIG_fail;
31190 }
31191 {
31192 #if wxUSE_UNICODE
31193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31194 #else
31195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31196 #endif
31197 }
31198 return resultobj;
31199 fail:
31200 return NULL;
31201 }
31202
31203
31204 static PyObject *_wrap_StandardPaths_GetUserDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31205 PyObject *resultobj;
31206 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31207 wxString result;
31208 PyObject * obj0 = 0 ;
31209 char *kwnames[] = {
31210 (char *) "self", NULL
31211 };
31212
31213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserDataDir",kwnames,&obj0)) goto fail;
31214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31215 if (SWIG_arg_fail(1)) SWIG_fail;
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 result = ((wxStandardPaths const *)arg1)->GetUserDataDir();
31219
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 {
31224 #if wxUSE_UNICODE
31225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31226 #else
31227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31228 #endif
31229 }
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 static PyObject *_wrap_StandardPaths_GetUserLocalDataDir(PyObject *, PyObject *args, PyObject *kwargs) {
31237 PyObject *resultobj;
31238 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31239 wxString result;
31240 PyObject * obj0 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetUserLocalDataDir",kwnames,&obj0)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 PyThreadState* __tstate = wxPyBeginAllowThreads();
31250 result = ((wxStandardPaths const *)arg1)->GetUserLocalDataDir();
31251
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 {
31256 #if wxUSE_UNICODE
31257 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31258 #else
31259 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31260 #endif
31261 }
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 static PyObject *_wrap_StandardPaths_GetPluginsDir(PyObject *, PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj;
31270 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31271 wxString result;
31272 PyObject * obj0 = 0 ;
31273 char *kwnames[] = {
31274 (char *) "self", NULL
31275 };
31276
31277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetPluginsDir",kwnames,&obj0)) goto fail;
31278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31279 if (SWIG_arg_fail(1)) SWIG_fail;
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 result = ((wxStandardPaths const *)arg1)->GetPluginsDir();
31283
31284 wxPyEndAllowThreads(__tstate);
31285 if (PyErr_Occurred()) SWIG_fail;
31286 }
31287 {
31288 #if wxUSE_UNICODE
31289 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31290 #else
31291 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31292 #endif
31293 }
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 static PyObject *_wrap_StandardPaths_SetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31301 PyObject *resultobj;
31302 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31303 wxString *arg2 = 0 ;
31304 bool temp2 = false ;
31305 PyObject * obj0 = 0 ;
31306 PyObject * obj1 = 0 ;
31307 char *kwnames[] = {
31308 (char *) "self",(char *) "prefix", NULL
31309 };
31310
31311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StandardPaths_SetInstallPrefix",kwnames,&obj0,&obj1)) goto fail;
31312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31313 if (SWIG_arg_fail(1)) SWIG_fail;
31314 {
31315 arg2 = wxString_in_helper(obj1);
31316 if (arg2 == NULL) SWIG_fail;
31317 temp2 = true;
31318 }
31319 {
31320 PyThreadState* __tstate = wxPyBeginAllowThreads();
31321 wxStandardPaths_SetInstallPrefix(arg1,(wxString const &)*arg2);
31322
31323 wxPyEndAllowThreads(__tstate);
31324 if (PyErr_Occurred()) SWIG_fail;
31325 }
31326 Py_INCREF(Py_None); resultobj = Py_None;
31327 {
31328 if (temp2)
31329 delete arg2;
31330 }
31331 return resultobj;
31332 fail:
31333 {
31334 if (temp2)
31335 delete arg2;
31336 }
31337 return NULL;
31338 }
31339
31340
31341 static PyObject *_wrap_StandardPaths_GetInstallPrefix(PyObject *, PyObject *args, PyObject *kwargs) {
31342 PyObject *resultobj;
31343 wxStandardPaths *arg1 = (wxStandardPaths *) 0 ;
31344 wxString result;
31345 PyObject * obj0 = 0 ;
31346 char *kwnames[] = {
31347 (char *) "self", NULL
31348 };
31349
31350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StandardPaths_GetInstallPrefix",kwnames,&obj0)) goto fail;
31351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStandardPaths, SWIG_POINTER_EXCEPTION | 0);
31352 if (SWIG_arg_fail(1)) SWIG_fail;
31353 {
31354 PyThreadState* __tstate = wxPyBeginAllowThreads();
31355 result = wxStandardPaths_GetInstallPrefix(arg1);
31356
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 {
31361 #if wxUSE_UNICODE
31362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31363 #else
31364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31365 #endif
31366 }
31367 return resultobj;
31368 fail:
31369 return NULL;
31370 }
31371
31372
31373 static PyObject * StandardPaths_swigregister(PyObject *, PyObject *args) {
31374 PyObject *obj;
31375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31376 SWIG_TypeClientData(SWIGTYPE_p_wxStandardPaths, obj);
31377 Py_INCREF(obj);
31378 return Py_BuildValue((char *)"");
31379 }
31380 static PyMethodDef SwigMethods[] = {
31381 { (char *)"SystemSettings_GetColour", (PyCFunction) _wrap_SystemSettings_GetColour, METH_VARARGS | METH_KEYWORDS, NULL},
31382 { (char *)"SystemSettings_GetFont", (PyCFunction) _wrap_SystemSettings_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
31383 { (char *)"SystemSettings_GetMetric", (PyCFunction) _wrap_SystemSettings_GetMetric, METH_VARARGS | METH_KEYWORDS, NULL},
31384 { (char *)"SystemSettings_HasFeature", (PyCFunction) _wrap_SystemSettings_HasFeature, METH_VARARGS | METH_KEYWORDS, NULL},
31385 { (char *)"SystemSettings_GetScreenType", (PyCFunction) _wrap_SystemSettings_GetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31386 { (char *)"SystemSettings_SetScreenType", (PyCFunction) _wrap_SystemSettings_SetScreenType, METH_VARARGS | METH_KEYWORDS, NULL},
31387 { (char *)"SystemSettings_swigregister", SystemSettings_swigregister, METH_VARARGS, NULL},
31388 { (char *)"new_SystemOptions", (PyCFunction) _wrap_new_SystemOptions, METH_VARARGS | METH_KEYWORDS, NULL},
31389 { (char *)"SystemOptions_SetOption", (PyCFunction) _wrap_SystemOptions_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31390 { (char *)"SystemOptions_SetOptionInt", (PyCFunction) _wrap_SystemOptions_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31391 { (char *)"SystemOptions_GetOption", (PyCFunction) _wrap_SystemOptions_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
31392 { (char *)"SystemOptions_GetOptionInt", (PyCFunction) _wrap_SystemOptions_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
31393 { (char *)"SystemOptions_HasOption", (PyCFunction) _wrap_SystemOptions_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
31394 { (char *)"SystemOptions_swigregister", SystemOptions_swigregister, METH_VARARGS, NULL},
31395 { (char *)"NewId", (PyCFunction) _wrap_NewId, METH_VARARGS | METH_KEYWORDS, NULL},
31396 { (char *)"RegisterId", (PyCFunction) _wrap_RegisterId, METH_VARARGS | METH_KEYWORDS, NULL},
31397 { (char *)"GetCurrentId", (PyCFunction) _wrap_GetCurrentId, METH_VARARGS | METH_KEYWORDS, NULL},
31398 { (char *)"IsStockID", (PyCFunction) _wrap_IsStockID, METH_VARARGS | METH_KEYWORDS, NULL},
31399 { (char *)"IsStockLabel", (PyCFunction) _wrap_IsStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31400 { (char *)"GetStockLabel", (PyCFunction) _wrap_GetStockLabel, METH_VARARGS | METH_KEYWORDS, NULL},
31401 { (char *)"Bell", (PyCFunction) _wrap_Bell, METH_VARARGS | METH_KEYWORDS, NULL},
31402 { (char *)"EndBusyCursor", (PyCFunction) _wrap_EndBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31403 { (char *)"GetElapsedTime", (PyCFunction) _wrap_GetElapsedTime, METH_VARARGS | METH_KEYWORDS, NULL},
31404 { (char *)"GetMousePosition", (PyCFunction) _wrap_GetMousePosition, METH_VARARGS | METH_KEYWORDS, NULL},
31405 { (char *)"IsBusy", (PyCFunction) _wrap_IsBusy, METH_VARARGS | METH_KEYWORDS, NULL},
31406 { (char *)"Now", (PyCFunction) _wrap_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31407 { (char *)"Shell", (PyCFunction) _wrap_Shell, METH_VARARGS | METH_KEYWORDS, NULL},
31408 { (char *)"StartTimer", (PyCFunction) _wrap_StartTimer, METH_VARARGS | METH_KEYWORDS, NULL},
31409 { (char *)"GetOsVersion", (PyCFunction) _wrap_GetOsVersion, METH_VARARGS | METH_KEYWORDS, NULL},
31410 { (char *)"GetOsDescription", (PyCFunction) _wrap_GetOsDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31411 { (char *)"GetFreeMemory", (PyCFunction) _wrap_GetFreeMemory, METH_VARARGS | METH_KEYWORDS, NULL},
31412 { (char *)"Shutdown", (PyCFunction) _wrap_Shutdown, METH_VARARGS | METH_KEYWORDS, NULL},
31413 { (char *)"Sleep", (PyCFunction) _wrap_Sleep, METH_VARARGS | METH_KEYWORDS, NULL},
31414 { (char *)"MilliSleep", (PyCFunction) _wrap_MilliSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31415 { (char *)"MicroSleep", (PyCFunction) _wrap_MicroSleep, METH_VARARGS | METH_KEYWORDS, NULL},
31416 { (char *)"EnableTopLevelWindows", (PyCFunction) _wrap_EnableTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
31417 { (char *)"StripMenuCodes", (PyCFunction) _wrap_StripMenuCodes, METH_VARARGS | METH_KEYWORDS, NULL},
31418 { (char *)"GetEmailAddress", (PyCFunction) _wrap_GetEmailAddress, METH_VARARGS | METH_KEYWORDS, NULL},
31419 { (char *)"GetHostName", (PyCFunction) _wrap_GetHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31420 { (char *)"GetFullHostName", (PyCFunction) _wrap_GetFullHostName, METH_VARARGS | METH_KEYWORDS, NULL},
31421 { (char *)"GetUserId", (PyCFunction) _wrap_GetUserId, METH_VARARGS | METH_KEYWORDS, NULL},
31422 { (char *)"GetUserName", (PyCFunction) _wrap_GetUserName, METH_VARARGS | METH_KEYWORDS, NULL},
31423 { (char *)"GetHomeDir", (PyCFunction) _wrap_GetHomeDir, METH_VARARGS | METH_KEYWORDS, NULL},
31424 { (char *)"GetUserHome", (PyCFunction) _wrap_GetUserHome, METH_VARARGS | METH_KEYWORDS, NULL},
31425 { (char *)"GetProcessId", (PyCFunction) _wrap_GetProcessId, METH_VARARGS | METH_KEYWORDS, NULL},
31426 { (char *)"Trap", (PyCFunction) _wrap_Trap, METH_VARARGS | METH_KEYWORDS, NULL},
31427 { (char *)"FileSelector", (PyCFunction) _wrap_FileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31428 { (char *)"LoadFileSelector", (PyCFunction) _wrap_LoadFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31429 { (char *)"SaveFileSelector", (PyCFunction) _wrap_SaveFileSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31430 { (char *)"DirSelector", (PyCFunction) _wrap_DirSelector, METH_VARARGS | METH_KEYWORDS, NULL},
31431 { (char *)"GetTextFromUser", (PyCFunction) _wrap_GetTextFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31432 { (char *)"GetPasswordFromUser", (PyCFunction) _wrap_GetPasswordFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31433 { (char *)"GetSingleChoice", (PyCFunction) _wrap_GetSingleChoice, METH_VARARGS | METH_KEYWORDS, NULL},
31434 { (char *)"GetSingleChoiceIndex", (PyCFunction) _wrap_GetSingleChoiceIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31435 { (char *)"MessageBox", (PyCFunction) _wrap_MessageBox, METH_VARARGS | METH_KEYWORDS, NULL},
31436 { (char *)"GetNumberFromUser", (PyCFunction) _wrap_GetNumberFromUser, METH_VARARGS | METH_KEYWORDS, NULL},
31437 { (char *)"ColourDisplay", (PyCFunction) _wrap_ColourDisplay, METH_VARARGS | METH_KEYWORDS, NULL},
31438 { (char *)"DisplayDepth", (PyCFunction) _wrap_DisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31439 { (char *)"GetDisplayDepth", (PyCFunction) _wrap_GetDisplayDepth, METH_VARARGS | METH_KEYWORDS, NULL},
31440 { (char *)"DisplaySize", (PyCFunction) _wrap_DisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31441 { (char *)"GetDisplaySize", (PyCFunction) _wrap_GetDisplaySize, METH_VARARGS | METH_KEYWORDS, NULL},
31442 { (char *)"DisplaySizeMM", (PyCFunction) _wrap_DisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31443 { (char *)"GetDisplaySizeMM", (PyCFunction) _wrap_GetDisplaySizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
31444 { (char *)"ClientDisplayRect", (PyCFunction) _wrap_ClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31445 { (char *)"GetClientDisplayRect", (PyCFunction) _wrap_GetClientDisplayRect, METH_VARARGS | METH_KEYWORDS, NULL},
31446 { (char *)"SetCursor", (PyCFunction) _wrap_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31447 { (char *)"BeginBusyCursor", (PyCFunction) _wrap_BeginBusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31448 { (char *)"GetActiveWindow", (PyCFunction) _wrap_GetActiveWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31449 { (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31450 { (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
31451 { (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS, NULL},
31452 { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS, NULL},
31453 { (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS, NULL},
31454 { (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS, NULL},
31455 { (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS, NULL},
31456 { (char *)"new_MutexGuiLocker", (PyCFunction) _wrap_new_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31457 { (char *)"delete_MutexGuiLocker", (PyCFunction) _wrap_delete_MutexGuiLocker, METH_VARARGS | METH_KEYWORDS, NULL},
31458 { (char *)"MutexGuiLocker_swigregister", MutexGuiLocker_swigregister, METH_VARARGS, NULL},
31459 { (char *)"Thread_IsMain", (PyCFunction) _wrap_Thread_IsMain, METH_VARARGS | METH_KEYWORDS, NULL},
31460 { (char *)"new_ToolTip", (PyCFunction) _wrap_new_ToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
31461 { (char *)"ToolTip_SetTip", (PyCFunction) _wrap_ToolTip_SetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31462 { (char *)"ToolTip_GetTip", (PyCFunction) _wrap_ToolTip_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31463 { (char *)"ToolTip_GetWindow", (PyCFunction) _wrap_ToolTip_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31464 { (char *)"ToolTip_Enable", (PyCFunction) _wrap_ToolTip_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
31465 { (char *)"ToolTip_SetDelay", (PyCFunction) _wrap_ToolTip_SetDelay, METH_VARARGS | METH_KEYWORDS, NULL},
31466 { (char *)"ToolTip_swigregister", ToolTip_swigregister, METH_VARARGS, NULL},
31467 { (char *)"new_Caret", (PyCFunction) _wrap_new_Caret, METH_VARARGS | METH_KEYWORDS, NULL},
31468 { (char *)"Caret_Destroy", (PyCFunction) _wrap_Caret_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31469 { (char *)"Caret_IsOk", (PyCFunction) _wrap_Caret_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31470 { (char *)"Caret_IsVisible", (PyCFunction) _wrap_Caret_IsVisible, METH_VARARGS | METH_KEYWORDS, NULL},
31471 { (char *)"Caret_GetPosition", (PyCFunction) _wrap_Caret_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31472 { (char *)"Caret_GetPositionTuple", (PyCFunction) _wrap_Caret_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31473 { (char *)"Caret_GetSize", (PyCFunction) _wrap_Caret_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31474 { (char *)"Caret_GetSizeTuple", (PyCFunction) _wrap_Caret_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
31475 { (char *)"Caret_GetWindow", (PyCFunction) _wrap_Caret_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31476 { (char *)"Caret_MoveXY", (PyCFunction) _wrap_Caret_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
31477 { (char *)"Caret_Move", (PyCFunction) _wrap_Caret_Move, METH_VARARGS | METH_KEYWORDS, NULL},
31478 { (char *)"Caret_SetSizeWH", (PyCFunction) _wrap_Caret_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
31479 { (char *)"Caret_SetSize", (PyCFunction) _wrap_Caret_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31480 { (char *)"Caret_Show", (PyCFunction) _wrap_Caret_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31481 { (char *)"Caret_Hide", (PyCFunction) _wrap_Caret_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
31482 { (char *)"Caret_GetBlinkTime", (PyCFunction) _wrap_Caret_GetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31483 { (char *)"Caret_SetBlinkTime", (PyCFunction) _wrap_Caret_SetBlinkTime, METH_VARARGS | METH_KEYWORDS, NULL},
31484 { (char *)"Caret_swigregister", Caret_swigregister, METH_VARARGS, NULL},
31485 { (char *)"new_BusyCursor", (PyCFunction) _wrap_new_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31486 { (char *)"delete_BusyCursor", (PyCFunction) _wrap_delete_BusyCursor, METH_VARARGS | METH_KEYWORDS, NULL},
31487 { (char *)"BusyCursor_swigregister", BusyCursor_swigregister, METH_VARARGS, NULL},
31488 { (char *)"new_WindowDisabler", (PyCFunction) _wrap_new_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31489 { (char *)"delete_WindowDisabler", (PyCFunction) _wrap_delete_WindowDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
31490 { (char *)"WindowDisabler_swigregister", WindowDisabler_swigregister, METH_VARARGS, NULL},
31491 { (char *)"new_BusyInfo", (PyCFunction) _wrap_new_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31492 { (char *)"delete_BusyInfo", (PyCFunction) _wrap_delete_BusyInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31493 { (char *)"BusyInfo_swigregister", BusyInfo_swigregister, METH_VARARGS, NULL},
31494 { (char *)"new_StopWatch", (PyCFunction) _wrap_new_StopWatch, METH_VARARGS | METH_KEYWORDS, NULL},
31495 { (char *)"StopWatch_Start", (PyCFunction) _wrap_StopWatch_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31496 { (char *)"StopWatch_Pause", (PyCFunction) _wrap_StopWatch_Pause, METH_VARARGS | METH_KEYWORDS, NULL},
31497 { (char *)"StopWatch_Resume", (PyCFunction) _wrap_StopWatch_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31498 { (char *)"StopWatch_Time", (PyCFunction) _wrap_StopWatch_Time, METH_VARARGS | METH_KEYWORDS, NULL},
31499 { (char *)"StopWatch_swigregister", StopWatch_swigregister, METH_VARARGS, NULL},
31500 { (char *)"new_FileHistory", (PyCFunction) _wrap_new_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31501 { (char *)"delete_FileHistory", (PyCFunction) _wrap_delete_FileHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31502 { (char *)"FileHistory_AddFileToHistory", (PyCFunction) _wrap_FileHistory_AddFileToHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31503 { (char *)"FileHistory_RemoveFileFromHistory", (PyCFunction) _wrap_FileHistory_RemoveFileFromHistory, METH_VARARGS | METH_KEYWORDS, NULL},
31504 { (char *)"FileHistory_GetMaxFiles", (PyCFunction) _wrap_FileHistory_GetMaxFiles, METH_VARARGS | METH_KEYWORDS, NULL},
31505 { (char *)"FileHistory_UseMenu", (PyCFunction) _wrap_FileHistory_UseMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31506 { (char *)"FileHistory_RemoveMenu", (PyCFunction) _wrap_FileHistory_RemoveMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31507 { (char *)"FileHistory_Load", (PyCFunction) _wrap_FileHistory_Load, METH_VARARGS | METH_KEYWORDS, NULL},
31508 { (char *)"FileHistory_Save", (PyCFunction) _wrap_FileHistory_Save, METH_VARARGS | METH_KEYWORDS, NULL},
31509 { (char *)"FileHistory_AddFilesToMenu", (PyCFunction) _wrap_FileHistory_AddFilesToMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31510 { (char *)"FileHistory_AddFilesToThisMenu", (PyCFunction) _wrap_FileHistory_AddFilesToThisMenu, METH_VARARGS | METH_KEYWORDS, NULL},
31511 { (char *)"FileHistory_GetHistoryFile", (PyCFunction) _wrap_FileHistory_GetHistoryFile, METH_VARARGS | METH_KEYWORDS, NULL},
31512 { (char *)"FileHistory_GetCount", (PyCFunction) _wrap_FileHistory_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
31513 { (char *)"FileHistory_swigregister", FileHistory_swigregister, METH_VARARGS, NULL},
31514 { (char *)"new_SingleInstanceChecker", (PyCFunction) _wrap_new_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31515 { (char *)"new_PreSingleInstanceChecker", (PyCFunction) _wrap_new_PreSingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31516 { (char *)"delete_SingleInstanceChecker", (PyCFunction) _wrap_delete_SingleInstanceChecker, METH_VARARGS | METH_KEYWORDS, NULL},
31517 { (char *)"SingleInstanceChecker_Create", (PyCFunction) _wrap_SingleInstanceChecker_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31518 { (char *)"SingleInstanceChecker_IsAnotherRunning", (PyCFunction) _wrap_SingleInstanceChecker_IsAnotherRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31519 { (char *)"SingleInstanceChecker_swigregister", SingleInstanceChecker_swigregister, METH_VARARGS, NULL},
31520 { (char *)"DrawWindowOnDC", (PyCFunction) _wrap_DrawWindowOnDC, METH_VARARGS | METH_KEYWORDS, NULL},
31521 { (char *)"delete_TipProvider", (PyCFunction) _wrap_delete_TipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31522 { (char *)"TipProvider_GetTip", (PyCFunction) _wrap_TipProvider_GetTip, METH_VARARGS | METH_KEYWORDS, NULL},
31523 { (char *)"TipProvider_GetCurrentTip", (PyCFunction) _wrap_TipProvider_GetCurrentTip, METH_VARARGS | METH_KEYWORDS, NULL},
31524 { (char *)"TipProvider_PreprocessTip", (PyCFunction) _wrap_TipProvider_PreprocessTip, METH_VARARGS | METH_KEYWORDS, NULL},
31525 { (char *)"TipProvider_swigregister", TipProvider_swigregister, METH_VARARGS, NULL},
31526 { (char *)"new_PyTipProvider", (PyCFunction) _wrap_new_PyTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31527 { (char *)"PyTipProvider__setCallbackInfo", (PyCFunction) _wrap_PyTipProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31528 { (char *)"PyTipProvider_swigregister", PyTipProvider_swigregister, METH_VARARGS, NULL},
31529 { (char *)"ShowTip", (PyCFunction) _wrap_ShowTip, METH_VARARGS | METH_KEYWORDS, NULL},
31530 { (char *)"CreateFileTipProvider", (PyCFunction) _wrap_CreateFileTipProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31531 { (char *)"new_Timer", (PyCFunction) _wrap_new_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31532 { (char *)"delete_Timer", (PyCFunction) _wrap_delete_Timer, METH_VARARGS | METH_KEYWORDS, NULL},
31533 { (char *)"Timer__setCallbackInfo", (PyCFunction) _wrap_Timer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31534 { (char *)"Timer_SetOwner", (PyCFunction) _wrap_Timer_SetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31535 { (char *)"Timer_GetOwner", (PyCFunction) _wrap_Timer_GetOwner, METH_VARARGS | METH_KEYWORDS, NULL},
31536 { (char *)"Timer_Start", (PyCFunction) _wrap_Timer_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31537 { (char *)"Timer_Stop", (PyCFunction) _wrap_Timer_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31538 { (char *)"Timer_IsRunning", (PyCFunction) _wrap_Timer_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
31539 { (char *)"Timer_GetInterval", (PyCFunction) _wrap_Timer_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31540 { (char *)"Timer_IsOneShot", (PyCFunction) _wrap_Timer_IsOneShot, METH_VARARGS | METH_KEYWORDS, NULL},
31541 { (char *)"Timer_GetId", (PyCFunction) _wrap_Timer_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
31542 { (char *)"Timer_swigregister", Timer_swigregister, METH_VARARGS, NULL},
31543 { (char *)"new_TimerEvent", (PyCFunction) _wrap_new_TimerEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31544 { (char *)"TimerEvent_GetInterval", (PyCFunction) _wrap_TimerEvent_GetInterval, METH_VARARGS | METH_KEYWORDS, NULL},
31545 { (char *)"TimerEvent_swigregister", TimerEvent_swigregister, METH_VARARGS, NULL},
31546 { (char *)"new_TimerRunner", _wrap_new_TimerRunner, METH_VARARGS, NULL},
31547 { (char *)"delete_TimerRunner", (PyCFunction) _wrap_delete_TimerRunner, METH_VARARGS | METH_KEYWORDS, NULL},
31548 { (char *)"TimerRunner_Start", (PyCFunction) _wrap_TimerRunner_Start, METH_VARARGS | METH_KEYWORDS, NULL},
31549 { (char *)"TimerRunner_swigregister", TimerRunner_swigregister, METH_VARARGS, NULL},
31550 { (char *)"new_Log", (PyCFunction) _wrap_new_Log, METH_VARARGS | METH_KEYWORDS, NULL},
31551 { (char *)"Log_IsEnabled", (PyCFunction) _wrap_Log_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
31552 { (char *)"Log_EnableLogging", (PyCFunction) _wrap_Log_EnableLogging, METH_VARARGS | METH_KEYWORDS, NULL},
31553 { (char *)"Log_OnLog", (PyCFunction) _wrap_Log_OnLog, METH_VARARGS | METH_KEYWORDS, NULL},
31554 { (char *)"Log_Flush", (PyCFunction) _wrap_Log_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31555 { (char *)"Log_FlushActive", (PyCFunction) _wrap_Log_FlushActive, METH_VARARGS | METH_KEYWORDS, NULL},
31556 { (char *)"Log_GetActiveTarget", (PyCFunction) _wrap_Log_GetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31557 { (char *)"Log_SetActiveTarget", (PyCFunction) _wrap_Log_SetActiveTarget, METH_VARARGS | METH_KEYWORDS, NULL},
31558 { (char *)"Log_Suspend", (PyCFunction) _wrap_Log_Suspend, METH_VARARGS | METH_KEYWORDS, NULL},
31559 { (char *)"Log_Resume", (PyCFunction) _wrap_Log_Resume, METH_VARARGS | METH_KEYWORDS, NULL},
31560 { (char *)"Log_SetVerbose", (PyCFunction) _wrap_Log_SetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31561 { (char *)"Log_SetLogLevel", (PyCFunction) _wrap_Log_SetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31562 { (char *)"Log_DontCreateOnDemand", (PyCFunction) _wrap_Log_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31563 { (char *)"Log_SetTraceMask", (PyCFunction) _wrap_Log_SetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31564 { (char *)"Log_AddTraceMask", (PyCFunction) _wrap_Log_AddTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31565 { (char *)"Log_RemoveTraceMask", (PyCFunction) _wrap_Log_RemoveTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31566 { (char *)"Log_ClearTraceMasks", (PyCFunction) _wrap_Log_ClearTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31567 { (char *)"Log_GetTraceMasks", (PyCFunction) _wrap_Log_GetTraceMasks, METH_VARARGS | METH_KEYWORDS, NULL},
31568 { (char *)"Log_SetTimestamp", (PyCFunction) _wrap_Log_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31569 { (char *)"Log_GetVerbose", (PyCFunction) _wrap_Log_GetVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31570 { (char *)"Log_GetTraceMask", (PyCFunction) _wrap_Log_GetTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31571 { (char *)"Log_IsAllowedTraceMask", (PyCFunction) _wrap_Log_IsAllowedTraceMask, METH_VARARGS | METH_KEYWORDS, NULL},
31572 { (char *)"Log_GetLogLevel", (PyCFunction) _wrap_Log_GetLogLevel, METH_VARARGS | METH_KEYWORDS, NULL},
31573 { (char *)"Log_GetTimestamp", (PyCFunction) _wrap_Log_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
31574 { (char *)"Log_TimeStamp", (PyCFunction) _wrap_Log_TimeStamp, METH_VARARGS | METH_KEYWORDS, NULL},
31575 { (char *)"Log_Destroy", (PyCFunction) _wrap_Log_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31576 { (char *)"Log_swigregister", Log_swigregister, METH_VARARGS, NULL},
31577 { (char *)"new_LogStderr", (PyCFunction) _wrap_new_LogStderr, METH_VARARGS | METH_KEYWORDS, NULL},
31578 { (char *)"LogStderr_swigregister", LogStderr_swigregister, METH_VARARGS, NULL},
31579 { (char *)"new_LogTextCtrl", (PyCFunction) _wrap_new_LogTextCtrl, METH_VARARGS | METH_KEYWORDS, NULL},
31580 { (char *)"LogTextCtrl_swigregister", LogTextCtrl_swigregister, METH_VARARGS, NULL},
31581 { (char *)"new_LogGui", (PyCFunction) _wrap_new_LogGui, METH_VARARGS | METH_KEYWORDS, NULL},
31582 { (char *)"LogGui_swigregister", LogGui_swigregister, METH_VARARGS, NULL},
31583 { (char *)"new_LogWindow", (PyCFunction) _wrap_new_LogWindow, METH_VARARGS | METH_KEYWORDS, NULL},
31584 { (char *)"LogWindow_Show", (PyCFunction) _wrap_LogWindow_Show, METH_VARARGS | METH_KEYWORDS, NULL},
31585 { (char *)"LogWindow_GetFrame", (PyCFunction) _wrap_LogWindow_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31586 { (char *)"LogWindow_GetOldLog", (PyCFunction) _wrap_LogWindow_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31587 { (char *)"LogWindow_IsPassingMessages", (PyCFunction) _wrap_LogWindow_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31588 { (char *)"LogWindow_PassMessages", (PyCFunction) _wrap_LogWindow_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31589 { (char *)"LogWindow_swigregister", LogWindow_swigregister, METH_VARARGS, NULL},
31590 { (char *)"new_LogChain", (PyCFunction) _wrap_new_LogChain, METH_VARARGS | METH_KEYWORDS, NULL},
31591 { (char *)"LogChain_SetLog", (PyCFunction) _wrap_LogChain_SetLog, METH_VARARGS | METH_KEYWORDS, NULL},
31592 { (char *)"LogChain_PassMessages", (PyCFunction) _wrap_LogChain_PassMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31593 { (char *)"LogChain_IsPassingMessages", (PyCFunction) _wrap_LogChain_IsPassingMessages, METH_VARARGS | METH_KEYWORDS, NULL},
31594 { (char *)"LogChain_GetOldLog", (PyCFunction) _wrap_LogChain_GetOldLog, METH_VARARGS | METH_KEYWORDS, NULL},
31595 { (char *)"LogChain_swigregister", LogChain_swigregister, METH_VARARGS, NULL},
31596 { (char *)"SysErrorCode", (PyCFunction) _wrap_SysErrorCode, METH_VARARGS | METH_KEYWORDS, NULL},
31597 { (char *)"SysErrorMsg", (PyCFunction) _wrap_SysErrorMsg, METH_VARARGS | METH_KEYWORDS, NULL},
31598 { (char *)"LogFatalError", (PyCFunction) _wrap_LogFatalError, METH_VARARGS | METH_KEYWORDS, NULL},
31599 { (char *)"LogError", (PyCFunction) _wrap_LogError, METH_VARARGS | METH_KEYWORDS, NULL},
31600 { (char *)"LogWarning", (PyCFunction) _wrap_LogWarning, METH_VARARGS | METH_KEYWORDS, NULL},
31601 { (char *)"LogMessage", (PyCFunction) _wrap_LogMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31602 { (char *)"LogInfo", (PyCFunction) _wrap_LogInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31603 { (char *)"LogDebug", (PyCFunction) _wrap_LogDebug, METH_VARARGS | METH_KEYWORDS, NULL},
31604 { (char *)"LogVerbose", (PyCFunction) _wrap_LogVerbose, METH_VARARGS | METH_KEYWORDS, NULL},
31605 { (char *)"LogStatus", (PyCFunction) _wrap_LogStatus, METH_VARARGS | METH_KEYWORDS, NULL},
31606 { (char *)"LogStatusFrame", (PyCFunction) _wrap_LogStatusFrame, METH_VARARGS | METH_KEYWORDS, NULL},
31607 { (char *)"LogSysError", (PyCFunction) _wrap_LogSysError, METH_VARARGS | METH_KEYWORDS, NULL},
31608 { (char *)"LogGeneric", (PyCFunction) _wrap_LogGeneric, METH_VARARGS | METH_KEYWORDS, NULL},
31609 { (char *)"LogTrace", _wrap_LogTrace, METH_VARARGS, NULL},
31610 { (char *)"SafeShowMessage", (PyCFunction) _wrap_SafeShowMessage, METH_VARARGS | METH_KEYWORDS, NULL},
31611 { (char *)"new_LogNull", (PyCFunction) _wrap_new_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31612 { (char *)"delete_LogNull", (PyCFunction) _wrap_delete_LogNull, METH_VARARGS | METH_KEYWORDS, NULL},
31613 { (char *)"LogNull_swigregister", LogNull_swigregister, METH_VARARGS, NULL},
31614 { (char *)"new_PyLog", (PyCFunction) _wrap_new_PyLog, METH_VARARGS | METH_KEYWORDS, NULL},
31615 { (char *)"PyLog__setCallbackInfo", (PyCFunction) _wrap_PyLog__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31616 { (char *)"PyLog_swigregister", PyLog_swigregister, METH_VARARGS, NULL},
31617 { (char *)"Process_Kill", (PyCFunction) _wrap_Process_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31618 { (char *)"Process_Exists", (PyCFunction) _wrap_Process_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31619 { (char *)"Process_Open", (PyCFunction) _wrap_Process_Open, METH_VARARGS | METH_KEYWORDS, NULL},
31620 { (char *)"new_Process", (PyCFunction) _wrap_new_Process, METH_VARARGS | METH_KEYWORDS, NULL},
31621 { (char *)"Process__setCallbackInfo", (PyCFunction) _wrap_Process__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31622 { (char *)"Process_base_OnTerminate", (PyCFunction) _wrap_Process_base_OnTerminate, METH_VARARGS | METH_KEYWORDS, NULL},
31623 { (char *)"Process_Redirect", (PyCFunction) _wrap_Process_Redirect, METH_VARARGS | METH_KEYWORDS, NULL},
31624 { (char *)"Process_IsRedirected", (PyCFunction) _wrap_Process_IsRedirected, METH_VARARGS | METH_KEYWORDS, NULL},
31625 { (char *)"Process_Detach", (PyCFunction) _wrap_Process_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
31626 { (char *)"Process_GetInputStream", (PyCFunction) _wrap_Process_GetInputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31627 { (char *)"Process_GetErrorStream", (PyCFunction) _wrap_Process_GetErrorStream, METH_VARARGS | METH_KEYWORDS, NULL},
31628 { (char *)"Process_GetOutputStream", (PyCFunction) _wrap_Process_GetOutputStream, METH_VARARGS | METH_KEYWORDS, NULL},
31629 { (char *)"Process_CloseOutput", (PyCFunction) _wrap_Process_CloseOutput, METH_VARARGS | METH_KEYWORDS, NULL},
31630 { (char *)"Process_IsInputOpened", (PyCFunction) _wrap_Process_IsInputOpened, METH_VARARGS | METH_KEYWORDS, NULL},
31631 { (char *)"Process_IsInputAvailable", (PyCFunction) _wrap_Process_IsInputAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31632 { (char *)"Process_IsErrorAvailable", (PyCFunction) _wrap_Process_IsErrorAvailable, METH_VARARGS | METH_KEYWORDS, NULL},
31633 { (char *)"Process_swigregister", Process_swigregister, METH_VARARGS, NULL},
31634 { (char *)"new_ProcessEvent", (PyCFunction) _wrap_new_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31635 { (char *)"ProcessEvent_GetPid", (PyCFunction) _wrap_ProcessEvent_GetPid, METH_VARARGS | METH_KEYWORDS, NULL},
31636 { (char *)"ProcessEvent_GetExitCode", (PyCFunction) _wrap_ProcessEvent_GetExitCode, METH_VARARGS | METH_KEYWORDS, NULL},
31637 { (char *)"ProcessEvent_m_pid_set", (PyCFunction) _wrap_ProcessEvent_m_pid_set, METH_VARARGS | METH_KEYWORDS, NULL},
31638 { (char *)"ProcessEvent_m_pid_get", (PyCFunction) _wrap_ProcessEvent_m_pid_get, METH_VARARGS | METH_KEYWORDS, NULL},
31639 { (char *)"ProcessEvent_m_exitcode_set", (PyCFunction) _wrap_ProcessEvent_m_exitcode_set, METH_VARARGS | METH_KEYWORDS, NULL},
31640 { (char *)"ProcessEvent_m_exitcode_get", (PyCFunction) _wrap_ProcessEvent_m_exitcode_get, METH_VARARGS | METH_KEYWORDS, NULL},
31641 { (char *)"ProcessEvent_swigregister", ProcessEvent_swigregister, METH_VARARGS, NULL},
31642 { (char *)"Execute", (PyCFunction) _wrap_Execute, METH_VARARGS | METH_KEYWORDS, NULL},
31643 { (char *)"Kill", (PyCFunction) _wrap_Kill, METH_VARARGS | METH_KEYWORDS, NULL},
31644 { (char *)"new_Joystick", (PyCFunction) _wrap_new_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31645 { (char *)"delete_Joystick", (PyCFunction) _wrap_delete_Joystick, METH_VARARGS | METH_KEYWORDS, NULL},
31646 { (char *)"Joystick_GetPosition", (PyCFunction) _wrap_Joystick_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31647 { (char *)"Joystick_GetZPosition", (PyCFunction) _wrap_Joystick_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31648 { (char *)"Joystick_GetButtonState", (PyCFunction) _wrap_Joystick_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31649 { (char *)"Joystick_GetPOVPosition", (PyCFunction) _wrap_Joystick_GetPOVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31650 { (char *)"Joystick_GetPOVCTSPosition", (PyCFunction) _wrap_Joystick_GetPOVCTSPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31651 { (char *)"Joystick_GetRudderPosition", (PyCFunction) _wrap_Joystick_GetRudderPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31652 { (char *)"Joystick_GetUPosition", (PyCFunction) _wrap_Joystick_GetUPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31653 { (char *)"Joystick_GetVPosition", (PyCFunction) _wrap_Joystick_GetVPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31654 { (char *)"Joystick_GetMovementThreshold", (PyCFunction) _wrap_Joystick_GetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31655 { (char *)"Joystick_SetMovementThreshold", (PyCFunction) _wrap_Joystick_SetMovementThreshold, METH_VARARGS | METH_KEYWORDS, NULL},
31656 { (char *)"Joystick_IsOk", (PyCFunction) _wrap_Joystick_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31657 { (char *)"Joystick_GetNumberJoysticks", (PyCFunction) _wrap_Joystick_GetNumberJoysticks, METH_VARARGS | METH_KEYWORDS, NULL},
31658 { (char *)"Joystick_GetManufacturerId", (PyCFunction) _wrap_Joystick_GetManufacturerId, METH_VARARGS | METH_KEYWORDS, NULL},
31659 { (char *)"Joystick_GetProductId", (PyCFunction) _wrap_Joystick_GetProductId, METH_VARARGS | METH_KEYWORDS, NULL},
31660 { (char *)"Joystick_GetProductName", (PyCFunction) _wrap_Joystick_GetProductName, METH_VARARGS | METH_KEYWORDS, NULL},
31661 { (char *)"Joystick_GetXMin", (PyCFunction) _wrap_Joystick_GetXMin, METH_VARARGS | METH_KEYWORDS, NULL},
31662 { (char *)"Joystick_GetYMin", (PyCFunction) _wrap_Joystick_GetYMin, METH_VARARGS | METH_KEYWORDS, NULL},
31663 { (char *)"Joystick_GetZMin", (PyCFunction) _wrap_Joystick_GetZMin, METH_VARARGS | METH_KEYWORDS, NULL},
31664 { (char *)"Joystick_GetXMax", (PyCFunction) _wrap_Joystick_GetXMax, METH_VARARGS | METH_KEYWORDS, NULL},
31665 { (char *)"Joystick_GetYMax", (PyCFunction) _wrap_Joystick_GetYMax, METH_VARARGS | METH_KEYWORDS, NULL},
31666 { (char *)"Joystick_GetZMax", (PyCFunction) _wrap_Joystick_GetZMax, METH_VARARGS | METH_KEYWORDS, NULL},
31667 { (char *)"Joystick_GetNumberButtons", (PyCFunction) _wrap_Joystick_GetNumberButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31668 { (char *)"Joystick_GetNumberAxes", (PyCFunction) _wrap_Joystick_GetNumberAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31669 { (char *)"Joystick_GetMaxButtons", (PyCFunction) _wrap_Joystick_GetMaxButtons, METH_VARARGS | METH_KEYWORDS, NULL},
31670 { (char *)"Joystick_GetMaxAxes", (PyCFunction) _wrap_Joystick_GetMaxAxes, METH_VARARGS | METH_KEYWORDS, NULL},
31671 { (char *)"Joystick_GetPollingMin", (PyCFunction) _wrap_Joystick_GetPollingMin, METH_VARARGS | METH_KEYWORDS, NULL},
31672 { (char *)"Joystick_GetPollingMax", (PyCFunction) _wrap_Joystick_GetPollingMax, METH_VARARGS | METH_KEYWORDS, NULL},
31673 { (char *)"Joystick_GetRudderMin", (PyCFunction) _wrap_Joystick_GetRudderMin, METH_VARARGS | METH_KEYWORDS, NULL},
31674 { (char *)"Joystick_GetRudderMax", (PyCFunction) _wrap_Joystick_GetRudderMax, METH_VARARGS | METH_KEYWORDS, NULL},
31675 { (char *)"Joystick_GetUMin", (PyCFunction) _wrap_Joystick_GetUMin, METH_VARARGS | METH_KEYWORDS, NULL},
31676 { (char *)"Joystick_GetUMax", (PyCFunction) _wrap_Joystick_GetUMax, METH_VARARGS | METH_KEYWORDS, NULL},
31677 { (char *)"Joystick_GetVMin", (PyCFunction) _wrap_Joystick_GetVMin, METH_VARARGS | METH_KEYWORDS, NULL},
31678 { (char *)"Joystick_GetVMax", (PyCFunction) _wrap_Joystick_GetVMax, METH_VARARGS | METH_KEYWORDS, NULL},
31679 { (char *)"Joystick_HasRudder", (PyCFunction) _wrap_Joystick_HasRudder, METH_VARARGS | METH_KEYWORDS, NULL},
31680 { (char *)"Joystick_HasZ", (PyCFunction) _wrap_Joystick_HasZ, METH_VARARGS | METH_KEYWORDS, NULL},
31681 { (char *)"Joystick_HasU", (PyCFunction) _wrap_Joystick_HasU, METH_VARARGS | METH_KEYWORDS, NULL},
31682 { (char *)"Joystick_HasV", (PyCFunction) _wrap_Joystick_HasV, METH_VARARGS | METH_KEYWORDS, NULL},
31683 { (char *)"Joystick_HasPOV", (PyCFunction) _wrap_Joystick_HasPOV, METH_VARARGS | METH_KEYWORDS, NULL},
31684 { (char *)"Joystick_HasPOV4Dir", (PyCFunction) _wrap_Joystick_HasPOV4Dir, METH_VARARGS | METH_KEYWORDS, NULL},
31685 { (char *)"Joystick_HasPOVCTS", (PyCFunction) _wrap_Joystick_HasPOVCTS, METH_VARARGS | METH_KEYWORDS, NULL},
31686 { (char *)"Joystick_SetCapture", (PyCFunction) _wrap_Joystick_SetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31687 { (char *)"Joystick_ReleaseCapture", (PyCFunction) _wrap_Joystick_ReleaseCapture, METH_VARARGS | METH_KEYWORDS, NULL},
31688 { (char *)"Joystick_swigregister", Joystick_swigregister, METH_VARARGS, NULL},
31689 { (char *)"new_JoystickEvent", (PyCFunction) _wrap_new_JoystickEvent, METH_VARARGS | METH_KEYWORDS, NULL},
31690 { (char *)"JoystickEvent_GetPosition", (PyCFunction) _wrap_JoystickEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31691 { (char *)"JoystickEvent_GetZPosition", (PyCFunction) _wrap_JoystickEvent_GetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31692 { (char *)"JoystickEvent_GetButtonState", (PyCFunction) _wrap_JoystickEvent_GetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31693 { (char *)"JoystickEvent_GetButtonChange", (PyCFunction) _wrap_JoystickEvent_GetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31694 { (char *)"JoystickEvent_GetJoystick", (PyCFunction) _wrap_JoystickEvent_GetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31695 { (char *)"JoystickEvent_SetJoystick", (PyCFunction) _wrap_JoystickEvent_SetJoystick, METH_VARARGS | METH_KEYWORDS, NULL},
31696 { (char *)"JoystickEvent_SetButtonState", (PyCFunction) _wrap_JoystickEvent_SetButtonState, METH_VARARGS | METH_KEYWORDS, NULL},
31697 { (char *)"JoystickEvent_SetButtonChange", (PyCFunction) _wrap_JoystickEvent_SetButtonChange, METH_VARARGS | METH_KEYWORDS, NULL},
31698 { (char *)"JoystickEvent_SetPosition", (PyCFunction) _wrap_JoystickEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31699 { (char *)"JoystickEvent_SetZPosition", (PyCFunction) _wrap_JoystickEvent_SetZPosition, METH_VARARGS | METH_KEYWORDS, NULL},
31700 { (char *)"JoystickEvent_IsButton", (PyCFunction) _wrap_JoystickEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
31701 { (char *)"JoystickEvent_IsMove", (PyCFunction) _wrap_JoystickEvent_IsMove, METH_VARARGS | METH_KEYWORDS, NULL},
31702 { (char *)"JoystickEvent_IsZMove", (PyCFunction) _wrap_JoystickEvent_IsZMove, METH_VARARGS | METH_KEYWORDS, NULL},
31703 { (char *)"JoystickEvent_ButtonDown", (PyCFunction) _wrap_JoystickEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
31704 { (char *)"JoystickEvent_ButtonUp", (PyCFunction) _wrap_JoystickEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
31705 { (char *)"JoystickEvent_ButtonIsDown", (PyCFunction) _wrap_JoystickEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
31706 { (char *)"JoystickEvent_swigregister", JoystickEvent_swigregister, METH_VARARGS, NULL},
31707 { (char *)"new_Sound", (PyCFunction) _wrap_new_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31708 { (char *)"new_SoundFromData", (PyCFunction) _wrap_new_SoundFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31709 { (char *)"delete_Sound", (PyCFunction) _wrap_delete_Sound, METH_VARARGS | METH_KEYWORDS, NULL},
31710 { (char *)"Sound_Create", (PyCFunction) _wrap_Sound_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31711 { (char *)"Sound_CreateFromData", (PyCFunction) _wrap_Sound_CreateFromData, METH_VARARGS | METH_KEYWORDS, NULL},
31712 { (char *)"Sound_IsOk", (PyCFunction) _wrap_Sound_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
31713 { (char *)"Sound_Play", (PyCFunction) _wrap_Sound_Play, METH_VARARGS | METH_KEYWORDS, NULL},
31714 { (char *)"Sound_PlaySound", (PyCFunction) _wrap_Sound_PlaySound, METH_VARARGS | METH_KEYWORDS, NULL},
31715 { (char *)"Sound_Stop", (PyCFunction) _wrap_Sound_Stop, METH_VARARGS | METH_KEYWORDS, NULL},
31716 { (char *)"Sound_swigregister", Sound_swigregister, METH_VARARGS, NULL},
31717 { (char *)"new_FileTypeInfo", (PyCFunction) _wrap_new_FileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31718 { (char *)"new_FileTypeInfoSequence", (PyCFunction) _wrap_new_FileTypeInfoSequence, METH_VARARGS | METH_KEYWORDS, NULL},
31719 { (char *)"new_NullFileTypeInfo", (PyCFunction) _wrap_new_NullFileTypeInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31720 { (char *)"FileTypeInfo_IsValid", (PyCFunction) _wrap_FileTypeInfo_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31721 { (char *)"FileTypeInfo_SetIcon", (PyCFunction) _wrap_FileTypeInfo_SetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31722 { (char *)"FileTypeInfo_SetShortDesc", (PyCFunction) _wrap_FileTypeInfo_SetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31723 { (char *)"FileTypeInfo_GetMimeType", (PyCFunction) _wrap_FileTypeInfo_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31724 { (char *)"FileTypeInfo_GetOpenCommand", (PyCFunction) _wrap_FileTypeInfo_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31725 { (char *)"FileTypeInfo_GetPrintCommand", (PyCFunction) _wrap_FileTypeInfo_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31726 { (char *)"FileTypeInfo_GetShortDesc", (PyCFunction) _wrap_FileTypeInfo_GetShortDesc, METH_VARARGS | METH_KEYWORDS, NULL},
31727 { (char *)"FileTypeInfo_GetDescription", (PyCFunction) _wrap_FileTypeInfo_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31728 { (char *)"FileTypeInfo_GetExtensions", (PyCFunction) _wrap_FileTypeInfo_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31729 { (char *)"FileTypeInfo_GetExtensionsCount", (PyCFunction) _wrap_FileTypeInfo_GetExtensionsCount, METH_VARARGS | METH_KEYWORDS, NULL},
31730 { (char *)"FileTypeInfo_GetIconFile", (PyCFunction) _wrap_FileTypeInfo_GetIconFile, METH_VARARGS | METH_KEYWORDS, NULL},
31731 { (char *)"FileTypeInfo_GetIconIndex", (PyCFunction) _wrap_FileTypeInfo_GetIconIndex, METH_VARARGS | METH_KEYWORDS, NULL},
31732 { (char *)"FileTypeInfo_swigregister", FileTypeInfo_swigregister, METH_VARARGS, NULL},
31733 { (char *)"new_FileType", (PyCFunction) _wrap_new_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31734 { (char *)"delete_FileType", (PyCFunction) _wrap_delete_FileType, METH_VARARGS | METH_KEYWORDS, NULL},
31735 { (char *)"FileType_GetMimeType", (PyCFunction) _wrap_FileType_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31736 { (char *)"FileType_GetMimeTypes", (PyCFunction) _wrap_FileType_GetMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31737 { (char *)"FileType_GetExtensions", (PyCFunction) _wrap_FileType_GetExtensions, METH_VARARGS | METH_KEYWORDS, NULL},
31738 { (char *)"FileType_GetIcon", (PyCFunction) _wrap_FileType_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31739 { (char *)"FileType_GetIconInfo", (PyCFunction) _wrap_FileType_GetIconInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31740 { (char *)"FileType_GetDescription", (PyCFunction) _wrap_FileType_GetDescription, METH_VARARGS | METH_KEYWORDS, NULL},
31741 { (char *)"FileType_GetOpenCommand", (PyCFunction) _wrap_FileType_GetOpenCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31742 { (char *)"FileType_GetPrintCommand", (PyCFunction) _wrap_FileType_GetPrintCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31743 { (char *)"FileType_GetAllCommands", (PyCFunction) _wrap_FileType_GetAllCommands, METH_VARARGS | METH_KEYWORDS, NULL},
31744 { (char *)"FileType_SetCommand", (PyCFunction) _wrap_FileType_SetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31745 { (char *)"FileType_SetDefaultIcon", (PyCFunction) _wrap_FileType_SetDefaultIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31746 { (char *)"FileType_Unassociate", (PyCFunction) _wrap_FileType_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31747 { (char *)"FileType_ExpandCommand", (PyCFunction) _wrap_FileType_ExpandCommand, METH_VARARGS | METH_KEYWORDS, NULL},
31748 { (char *)"FileType_swigregister", FileType_swigregister, METH_VARARGS, NULL},
31749 { (char *)"MimeTypesManager_IsOfType", (PyCFunction) _wrap_MimeTypesManager_IsOfType, METH_VARARGS | METH_KEYWORDS, NULL},
31750 { (char *)"new_MimeTypesManager", (PyCFunction) _wrap_new_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31751 { (char *)"MimeTypesManager_Initialize", (PyCFunction) _wrap_MimeTypesManager_Initialize, METH_VARARGS | METH_KEYWORDS, NULL},
31752 { (char *)"MimeTypesManager_ClearData", (PyCFunction) _wrap_MimeTypesManager_ClearData, METH_VARARGS | METH_KEYWORDS, NULL},
31753 { (char *)"MimeTypesManager_GetFileTypeFromExtension", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromExtension, METH_VARARGS | METH_KEYWORDS, NULL},
31754 { (char *)"MimeTypesManager_GetFileTypeFromMimeType", (PyCFunction) _wrap_MimeTypesManager_GetFileTypeFromMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
31755 { (char *)"MimeTypesManager_ReadMailcap", (PyCFunction) _wrap_MimeTypesManager_ReadMailcap, METH_VARARGS | METH_KEYWORDS, NULL},
31756 { (char *)"MimeTypesManager_ReadMimeTypes", (PyCFunction) _wrap_MimeTypesManager_ReadMimeTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31757 { (char *)"MimeTypesManager_EnumAllFileTypes", (PyCFunction) _wrap_MimeTypesManager_EnumAllFileTypes, METH_VARARGS | METH_KEYWORDS, NULL},
31758 { (char *)"MimeTypesManager_AddFallback", (PyCFunction) _wrap_MimeTypesManager_AddFallback, METH_VARARGS | METH_KEYWORDS, NULL},
31759 { (char *)"MimeTypesManager_Associate", (PyCFunction) _wrap_MimeTypesManager_Associate, METH_VARARGS | METH_KEYWORDS, NULL},
31760 { (char *)"MimeTypesManager_Unassociate", (PyCFunction) _wrap_MimeTypesManager_Unassociate, METH_VARARGS | METH_KEYWORDS, NULL},
31761 { (char *)"delete_MimeTypesManager", (PyCFunction) _wrap_delete_MimeTypesManager, METH_VARARGS | METH_KEYWORDS, NULL},
31762 { (char *)"MimeTypesManager_swigregister", MimeTypesManager_swigregister, METH_VARARGS, NULL},
31763 { (char *)"new_ArtProvider", (PyCFunction) _wrap_new_ArtProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31764 { (char *)"ArtProvider__setCallbackInfo", (PyCFunction) _wrap_ArtProvider__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
31765 { (char *)"ArtProvider_PushProvider", (PyCFunction) _wrap_ArtProvider_PushProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31766 { (char *)"ArtProvider_PopProvider", (PyCFunction) _wrap_ArtProvider_PopProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31767 { (char *)"ArtProvider_RemoveProvider", (PyCFunction) _wrap_ArtProvider_RemoveProvider, METH_VARARGS | METH_KEYWORDS, NULL},
31768 { (char *)"ArtProvider_GetBitmap", (PyCFunction) _wrap_ArtProvider_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
31769 { (char *)"ArtProvider_GetIcon", (PyCFunction) _wrap_ArtProvider_GetIcon, METH_VARARGS | METH_KEYWORDS, NULL},
31770 { (char *)"ArtProvider_GetSize", (PyCFunction) _wrap_ArtProvider_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
31771 { (char *)"ArtProvider_Destroy", (PyCFunction) _wrap_ArtProvider_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
31772 { (char *)"ArtProvider_swigregister", ArtProvider_swigregister, METH_VARARGS, NULL},
31773 { (char *)"delete_ConfigBase", (PyCFunction) _wrap_delete_ConfigBase, METH_VARARGS | METH_KEYWORDS, NULL},
31774 { (char *)"ConfigBase_Set", (PyCFunction) _wrap_ConfigBase_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31775 { (char *)"ConfigBase_Get", (PyCFunction) _wrap_ConfigBase_Get, METH_VARARGS | METH_KEYWORDS, NULL},
31776 { (char *)"ConfigBase_Create", (PyCFunction) _wrap_ConfigBase_Create, METH_VARARGS | METH_KEYWORDS, NULL},
31777 { (char *)"ConfigBase_DontCreateOnDemand", (PyCFunction) _wrap_ConfigBase_DontCreateOnDemand, METH_VARARGS | METH_KEYWORDS, NULL},
31778 { (char *)"ConfigBase_SetPath", (PyCFunction) _wrap_ConfigBase_SetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31779 { (char *)"ConfigBase_GetPath", (PyCFunction) _wrap_ConfigBase_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
31780 { (char *)"ConfigBase_GetFirstGroup", (PyCFunction) _wrap_ConfigBase_GetFirstGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31781 { (char *)"ConfigBase_GetNextGroup", (PyCFunction) _wrap_ConfigBase_GetNextGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31782 { (char *)"ConfigBase_GetFirstEntry", (PyCFunction) _wrap_ConfigBase_GetFirstEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31783 { (char *)"ConfigBase_GetNextEntry", (PyCFunction) _wrap_ConfigBase_GetNextEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31784 { (char *)"ConfigBase_GetNumberOfEntries", (PyCFunction) _wrap_ConfigBase_GetNumberOfEntries, METH_VARARGS | METH_KEYWORDS, NULL},
31785 { (char *)"ConfigBase_GetNumberOfGroups", (PyCFunction) _wrap_ConfigBase_GetNumberOfGroups, METH_VARARGS | METH_KEYWORDS, NULL},
31786 { (char *)"ConfigBase_HasGroup", (PyCFunction) _wrap_ConfigBase_HasGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31787 { (char *)"ConfigBase_HasEntry", (PyCFunction) _wrap_ConfigBase_HasEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31788 { (char *)"ConfigBase_Exists", (PyCFunction) _wrap_ConfigBase_Exists, METH_VARARGS | METH_KEYWORDS, NULL},
31789 { (char *)"ConfigBase_GetEntryType", (PyCFunction) _wrap_ConfigBase_GetEntryType, METH_VARARGS | METH_KEYWORDS, NULL},
31790 { (char *)"ConfigBase_Read", (PyCFunction) _wrap_ConfigBase_Read, METH_VARARGS | METH_KEYWORDS, NULL},
31791 { (char *)"ConfigBase_ReadInt", (PyCFunction) _wrap_ConfigBase_ReadInt, METH_VARARGS | METH_KEYWORDS, NULL},
31792 { (char *)"ConfigBase_ReadFloat", (PyCFunction) _wrap_ConfigBase_ReadFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31793 { (char *)"ConfigBase_ReadBool", (PyCFunction) _wrap_ConfigBase_ReadBool, METH_VARARGS | METH_KEYWORDS, NULL},
31794 { (char *)"ConfigBase_Write", (PyCFunction) _wrap_ConfigBase_Write, METH_VARARGS | METH_KEYWORDS, NULL},
31795 { (char *)"ConfigBase_WriteInt", (PyCFunction) _wrap_ConfigBase_WriteInt, METH_VARARGS | METH_KEYWORDS, NULL},
31796 { (char *)"ConfigBase_WriteFloat", (PyCFunction) _wrap_ConfigBase_WriteFloat, METH_VARARGS | METH_KEYWORDS, NULL},
31797 { (char *)"ConfigBase_WriteBool", (PyCFunction) _wrap_ConfigBase_WriteBool, METH_VARARGS | METH_KEYWORDS, NULL},
31798 { (char *)"ConfigBase_Flush", (PyCFunction) _wrap_ConfigBase_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
31799 { (char *)"ConfigBase_RenameEntry", (PyCFunction) _wrap_ConfigBase_RenameEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31800 { (char *)"ConfigBase_RenameGroup", (PyCFunction) _wrap_ConfigBase_RenameGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31801 { (char *)"ConfigBase_DeleteEntry", (PyCFunction) _wrap_ConfigBase_DeleteEntry, METH_VARARGS | METH_KEYWORDS, NULL},
31802 { (char *)"ConfigBase_DeleteGroup", (PyCFunction) _wrap_ConfigBase_DeleteGroup, METH_VARARGS | METH_KEYWORDS, NULL},
31803 { (char *)"ConfigBase_DeleteAll", (PyCFunction) _wrap_ConfigBase_DeleteAll, METH_VARARGS | METH_KEYWORDS, NULL},
31804 { (char *)"ConfigBase_SetExpandEnvVars", (PyCFunction) _wrap_ConfigBase_SetExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31805 { (char *)"ConfigBase_IsExpandingEnvVars", (PyCFunction) _wrap_ConfigBase_IsExpandingEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31806 { (char *)"ConfigBase_SetRecordDefaults", (PyCFunction) _wrap_ConfigBase_SetRecordDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31807 { (char *)"ConfigBase_IsRecordingDefaults", (PyCFunction) _wrap_ConfigBase_IsRecordingDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
31808 { (char *)"ConfigBase_ExpandEnvVars", (PyCFunction) _wrap_ConfigBase_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31809 { (char *)"ConfigBase_GetAppName", (PyCFunction) _wrap_ConfigBase_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31810 { (char *)"ConfigBase_GetVendorName", (PyCFunction) _wrap_ConfigBase_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31811 { (char *)"ConfigBase_SetAppName", (PyCFunction) _wrap_ConfigBase_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
31812 { (char *)"ConfigBase_SetVendorName", (PyCFunction) _wrap_ConfigBase_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
31813 { (char *)"ConfigBase_SetStyle", (PyCFunction) _wrap_ConfigBase_SetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31814 { (char *)"ConfigBase_GetStyle", (PyCFunction) _wrap_ConfigBase_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
31815 { (char *)"ConfigBase_swigregister", ConfigBase_swigregister, METH_VARARGS, NULL},
31816 { (char *)"new_Config", (PyCFunction) _wrap_new_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31817 { (char *)"delete_Config", (PyCFunction) _wrap_delete_Config, METH_VARARGS | METH_KEYWORDS, NULL},
31818 { (char *)"Config_swigregister", Config_swigregister, METH_VARARGS, NULL},
31819 { (char *)"new_FileConfig", (PyCFunction) _wrap_new_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31820 { (char *)"delete_FileConfig", (PyCFunction) _wrap_delete_FileConfig, METH_VARARGS | METH_KEYWORDS, NULL},
31821 { (char *)"FileConfig_swigregister", FileConfig_swigregister, METH_VARARGS, NULL},
31822 { (char *)"new_ConfigPathChanger", (PyCFunction) _wrap_new_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31823 { (char *)"delete_ConfigPathChanger", (PyCFunction) _wrap_delete_ConfigPathChanger, METH_VARARGS | METH_KEYWORDS, NULL},
31824 { (char *)"ConfigPathChanger_Name", (PyCFunction) _wrap_ConfigPathChanger_Name, METH_VARARGS | METH_KEYWORDS, NULL},
31825 { (char *)"ConfigPathChanger_swigregister", ConfigPathChanger_swigregister, METH_VARARGS, NULL},
31826 { (char *)"ExpandEnvVars", (PyCFunction) _wrap_ExpandEnvVars, METH_VARARGS | METH_KEYWORDS, NULL},
31827 { (char *)"DateTime_SetCountry", (PyCFunction) _wrap_DateTime_SetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31828 { (char *)"DateTime_GetCountry", (PyCFunction) _wrap_DateTime_GetCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31829 { (char *)"DateTime_IsWestEuropeanCountry", (PyCFunction) _wrap_DateTime_IsWestEuropeanCountry, METH_VARARGS | METH_KEYWORDS, NULL},
31830 { (char *)"DateTime_GetCurrentYear", (PyCFunction) _wrap_DateTime_GetCurrentYear, METH_VARARGS | METH_KEYWORDS, NULL},
31831 { (char *)"DateTime_ConvertYearToBC", (PyCFunction) _wrap_DateTime_ConvertYearToBC, METH_VARARGS | METH_KEYWORDS, NULL},
31832 { (char *)"DateTime_GetCurrentMonth", (PyCFunction) _wrap_DateTime_GetCurrentMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31833 { (char *)"DateTime_IsLeapYear", (PyCFunction) _wrap_DateTime_IsLeapYear, METH_VARARGS | METH_KEYWORDS, NULL},
31834 { (char *)"DateTime_GetCentury", (PyCFunction) _wrap_DateTime_GetCentury, METH_VARARGS | METH_KEYWORDS, NULL},
31835 { (char *)"DateTime_GetNumberOfDaysinYear", (PyCFunction) _wrap_DateTime_GetNumberOfDaysinYear, METH_VARARGS | METH_KEYWORDS, NULL},
31836 { (char *)"DateTime_GetNumberOfDaysInMonth", (PyCFunction) _wrap_DateTime_GetNumberOfDaysInMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31837 { (char *)"DateTime_GetMonthName", (PyCFunction) _wrap_DateTime_GetMonthName, METH_VARARGS | METH_KEYWORDS, NULL},
31838 { (char *)"DateTime_GetWeekDayName", (PyCFunction) _wrap_DateTime_GetWeekDayName, METH_VARARGS | METH_KEYWORDS, NULL},
31839 { (char *)"DateTime_GetAmPmStrings", (PyCFunction) _wrap_DateTime_GetAmPmStrings, METH_VARARGS | METH_KEYWORDS, NULL},
31840 { (char *)"DateTime_IsDSTApplicable", (PyCFunction) _wrap_DateTime_IsDSTApplicable, METH_VARARGS | METH_KEYWORDS, NULL},
31841 { (char *)"DateTime_GetBeginDST", (PyCFunction) _wrap_DateTime_GetBeginDST, METH_VARARGS | METH_KEYWORDS, NULL},
31842 { (char *)"DateTime_GetEndDST", (PyCFunction) _wrap_DateTime_GetEndDST, METH_VARARGS | METH_KEYWORDS, NULL},
31843 { (char *)"DateTime_Now", (PyCFunction) _wrap_DateTime_Now, METH_VARARGS | METH_KEYWORDS, NULL},
31844 { (char *)"DateTime_UNow", (PyCFunction) _wrap_DateTime_UNow, METH_VARARGS | METH_KEYWORDS, NULL},
31845 { (char *)"DateTime_Today", (PyCFunction) _wrap_DateTime_Today, METH_VARARGS | METH_KEYWORDS, NULL},
31846 { (char *)"new_DateTime", (PyCFunction) _wrap_new_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31847 { (char *)"new_DateTimeFromTimeT", (PyCFunction) _wrap_new_DateTimeFromTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31848 { (char *)"new_DateTimeFromJDN", (PyCFunction) _wrap_new_DateTimeFromJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31849 { (char *)"new_DateTimeFromHMS", (PyCFunction) _wrap_new_DateTimeFromHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31850 { (char *)"new_DateTimeFromDMY", (PyCFunction) _wrap_new_DateTimeFromDMY, METH_VARARGS | METH_KEYWORDS, NULL},
31851 { (char *)"delete_DateTime", (PyCFunction) _wrap_delete_DateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31852 { (char *)"DateTime_SetToCurrent", (PyCFunction) _wrap_DateTime_SetToCurrent, METH_VARARGS | METH_KEYWORDS, NULL},
31853 { (char *)"DateTime_SetTimeT", (PyCFunction) _wrap_DateTime_SetTimeT, METH_VARARGS | METH_KEYWORDS, NULL},
31854 { (char *)"DateTime_SetJDN", (PyCFunction) _wrap_DateTime_SetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31855 { (char *)"DateTime_SetHMS", (PyCFunction) _wrap_DateTime_SetHMS, METH_VARARGS | METH_KEYWORDS, NULL},
31856 { (char *)"DateTime_Set", (PyCFunction) _wrap_DateTime_Set, METH_VARARGS | METH_KEYWORDS, NULL},
31857 { (char *)"DateTime_ResetTime", (PyCFunction) _wrap_DateTime_ResetTime, METH_VARARGS | METH_KEYWORDS, NULL},
31858 { (char *)"DateTime_SetYear", (PyCFunction) _wrap_DateTime_SetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31859 { (char *)"DateTime_SetMonth", (PyCFunction) _wrap_DateTime_SetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31860 { (char *)"DateTime_SetDay", (PyCFunction) _wrap_DateTime_SetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31861 { (char *)"DateTime_SetHour", (PyCFunction) _wrap_DateTime_SetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31862 { (char *)"DateTime_SetMinute", (PyCFunction) _wrap_DateTime_SetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31863 { (char *)"DateTime_SetSecond", (PyCFunction) _wrap_DateTime_SetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31864 { (char *)"DateTime_SetMillisecond", (PyCFunction) _wrap_DateTime_SetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31865 { (char *)"DateTime_SetToWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_SetToWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31866 { (char *)"DateTime_GetWeekDayInSameWeek", (PyCFunction) _wrap_DateTime_GetWeekDayInSameWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31867 { (char *)"DateTime_SetToNextWeekDay", (PyCFunction) _wrap_DateTime_SetToNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31868 { (char *)"DateTime_GetNextWeekDay", (PyCFunction) _wrap_DateTime_GetNextWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31869 { (char *)"DateTime_SetToPrevWeekDay", (PyCFunction) _wrap_DateTime_SetToPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31870 { (char *)"DateTime_GetPrevWeekDay", (PyCFunction) _wrap_DateTime_GetPrevWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31871 { (char *)"DateTime_SetToWeekDay", (PyCFunction) _wrap_DateTime_SetToWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31872 { (char *)"DateTime_SetToLastWeekDay", (PyCFunction) _wrap_DateTime_SetToLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31873 { (char *)"DateTime_GetLastWeekDay", (PyCFunction) _wrap_DateTime_GetLastWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31874 { (char *)"DateTime_SetToTheWeek", (PyCFunction) _wrap_DateTime_SetToTheWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31875 { (char *)"DateTime_GetWeek", (PyCFunction) _wrap_DateTime_GetWeek, METH_VARARGS | METH_KEYWORDS, NULL},
31876 { (char *)"DateTime_SetToWeekOfYear", (PyCFunction) _wrap_DateTime_SetToWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31877 { (char *)"DateTime_SetToLastMonthDay", (PyCFunction) _wrap_DateTime_SetToLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31878 { (char *)"DateTime_GetLastMonthDay", (PyCFunction) _wrap_DateTime_GetLastMonthDay, METH_VARARGS | METH_KEYWORDS, NULL},
31879 { (char *)"DateTime_SetToYearDay", (PyCFunction) _wrap_DateTime_SetToYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31880 { (char *)"DateTime_GetYearDay", (PyCFunction) _wrap_DateTime_GetYearDay, METH_VARARGS | METH_KEYWORDS, NULL},
31881 { (char *)"DateTime_GetJulianDayNumber", (PyCFunction) _wrap_DateTime_GetJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31882 { (char *)"DateTime_GetJDN", (PyCFunction) _wrap_DateTime_GetJDN, METH_VARARGS | METH_KEYWORDS, NULL},
31883 { (char *)"DateTime_GetModifiedJulianDayNumber", (PyCFunction) _wrap_DateTime_GetModifiedJulianDayNumber, METH_VARARGS | METH_KEYWORDS, NULL},
31884 { (char *)"DateTime_GetMJD", (PyCFunction) _wrap_DateTime_GetMJD, METH_VARARGS | METH_KEYWORDS, NULL},
31885 { (char *)"DateTime_GetRataDie", (PyCFunction) _wrap_DateTime_GetRataDie, METH_VARARGS | METH_KEYWORDS, NULL},
31886 { (char *)"DateTime_ToTimezone", (PyCFunction) _wrap_DateTime_ToTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31887 { (char *)"DateTime_MakeTimezone", (PyCFunction) _wrap_DateTime_MakeTimezone, METH_VARARGS | METH_KEYWORDS, NULL},
31888 { (char *)"DateTime_ToGMT", (PyCFunction) _wrap_DateTime_ToGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31889 { (char *)"DateTime_MakeGMT", (PyCFunction) _wrap_DateTime_MakeGMT, METH_VARARGS | METH_KEYWORDS, NULL},
31890 { (char *)"DateTime_IsDST", (PyCFunction) _wrap_DateTime_IsDST, METH_VARARGS | METH_KEYWORDS, NULL},
31891 { (char *)"DateTime_IsValid", (PyCFunction) _wrap_DateTime_IsValid, METH_VARARGS | METH_KEYWORDS, NULL},
31892 { (char *)"DateTime_GetTicks", (PyCFunction) _wrap_DateTime_GetTicks, METH_VARARGS | METH_KEYWORDS, NULL},
31893 { (char *)"DateTime_GetYear", (PyCFunction) _wrap_DateTime_GetYear, METH_VARARGS | METH_KEYWORDS, NULL},
31894 { (char *)"DateTime_GetMonth", (PyCFunction) _wrap_DateTime_GetMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31895 { (char *)"DateTime_GetDay", (PyCFunction) _wrap_DateTime_GetDay, METH_VARARGS | METH_KEYWORDS, NULL},
31896 { (char *)"DateTime_GetWeekDay", (PyCFunction) _wrap_DateTime_GetWeekDay, METH_VARARGS | METH_KEYWORDS, NULL},
31897 { (char *)"DateTime_GetHour", (PyCFunction) _wrap_DateTime_GetHour, METH_VARARGS | METH_KEYWORDS, NULL},
31898 { (char *)"DateTime_GetMinute", (PyCFunction) _wrap_DateTime_GetMinute, METH_VARARGS | METH_KEYWORDS, NULL},
31899 { (char *)"DateTime_GetSecond", (PyCFunction) _wrap_DateTime_GetSecond, METH_VARARGS | METH_KEYWORDS, NULL},
31900 { (char *)"DateTime_GetMillisecond", (PyCFunction) _wrap_DateTime_GetMillisecond, METH_VARARGS | METH_KEYWORDS, NULL},
31901 { (char *)"DateTime_GetDayOfYear", (PyCFunction) _wrap_DateTime_GetDayOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31902 { (char *)"DateTime_GetWeekOfYear", (PyCFunction) _wrap_DateTime_GetWeekOfYear, METH_VARARGS | METH_KEYWORDS, NULL},
31903 { (char *)"DateTime_GetWeekOfMonth", (PyCFunction) _wrap_DateTime_GetWeekOfMonth, METH_VARARGS | METH_KEYWORDS, NULL},
31904 { (char *)"DateTime_IsWorkDay", (PyCFunction) _wrap_DateTime_IsWorkDay, METH_VARARGS | METH_KEYWORDS, NULL},
31905 { (char *)"DateTime_IsEqualTo", (PyCFunction) _wrap_DateTime_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31906 { (char *)"DateTime_IsEarlierThan", (PyCFunction) _wrap_DateTime_IsEarlierThan, METH_VARARGS | METH_KEYWORDS, NULL},
31907 { (char *)"DateTime_IsLaterThan", (PyCFunction) _wrap_DateTime_IsLaterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31908 { (char *)"DateTime_IsStrictlyBetween", (PyCFunction) _wrap_DateTime_IsStrictlyBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31909 { (char *)"DateTime_IsBetween", (PyCFunction) _wrap_DateTime_IsBetween, METH_VARARGS | METH_KEYWORDS, NULL},
31910 { (char *)"DateTime_IsSameDate", (PyCFunction) _wrap_DateTime_IsSameDate, METH_VARARGS | METH_KEYWORDS, NULL},
31911 { (char *)"DateTime_IsSameTime", (PyCFunction) _wrap_DateTime_IsSameTime, METH_VARARGS | METH_KEYWORDS, NULL},
31912 { (char *)"DateTime_IsEqualUpTo", (PyCFunction) _wrap_DateTime_IsEqualUpTo, METH_VARARGS | METH_KEYWORDS, NULL},
31913 { (char *)"DateTime_AddTS", (PyCFunction) _wrap_DateTime_AddTS, METH_VARARGS | METH_KEYWORDS, NULL},
31914 { (char *)"DateTime_AddDS", (PyCFunction) _wrap_DateTime_AddDS, METH_VARARGS | METH_KEYWORDS, NULL},
31915 { (char *)"DateTime_SubtractTS", (PyCFunction) _wrap_DateTime_SubtractTS, METH_VARARGS | METH_KEYWORDS, NULL},
31916 { (char *)"DateTime_SubtractDS", (PyCFunction) _wrap_DateTime_SubtractDS, METH_VARARGS | METH_KEYWORDS, NULL},
31917 { (char *)"DateTime_Subtract", (PyCFunction) _wrap_DateTime_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31918 { (char *)"DateTime___iadd__", _wrap_DateTime___iadd__, METH_VARARGS, NULL},
31919 { (char *)"DateTime___isub__", _wrap_DateTime___isub__, METH_VARARGS, NULL},
31920 { (char *)"DateTime___add__", _wrap_DateTime___add__, METH_VARARGS, NULL},
31921 { (char *)"DateTime___sub__", _wrap_DateTime___sub__, METH_VARARGS, NULL},
31922 { (char *)"DateTime___lt__", (PyCFunction) _wrap_DateTime___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31923 { (char *)"DateTime___le__", (PyCFunction) _wrap_DateTime___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31924 { (char *)"DateTime___gt__", (PyCFunction) _wrap_DateTime___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31925 { (char *)"DateTime___ge__", (PyCFunction) _wrap_DateTime___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31926 { (char *)"DateTime___eq__", (PyCFunction) _wrap_DateTime___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31927 { (char *)"DateTime___ne__", (PyCFunction) _wrap_DateTime___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31928 { (char *)"DateTime_ParseRfc822Date", (PyCFunction) _wrap_DateTime_ParseRfc822Date, METH_VARARGS | METH_KEYWORDS, NULL},
31929 { (char *)"DateTime_ParseFormat", (PyCFunction) _wrap_DateTime_ParseFormat, METH_VARARGS | METH_KEYWORDS, NULL},
31930 { (char *)"DateTime_ParseDateTime", (PyCFunction) _wrap_DateTime_ParseDateTime, METH_VARARGS | METH_KEYWORDS, NULL},
31931 { (char *)"DateTime_ParseDate", (PyCFunction) _wrap_DateTime_ParseDate, METH_VARARGS | METH_KEYWORDS, NULL},
31932 { (char *)"DateTime_ParseTime", (PyCFunction) _wrap_DateTime_ParseTime, METH_VARARGS | METH_KEYWORDS, NULL},
31933 { (char *)"DateTime_Format", (PyCFunction) _wrap_DateTime_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31934 { (char *)"DateTime_FormatDate", (PyCFunction) _wrap_DateTime_FormatDate, METH_VARARGS | METH_KEYWORDS, NULL},
31935 { (char *)"DateTime_FormatTime", (PyCFunction) _wrap_DateTime_FormatTime, METH_VARARGS | METH_KEYWORDS, NULL},
31936 { (char *)"DateTime_FormatISODate", (PyCFunction) _wrap_DateTime_FormatISODate, METH_VARARGS | METH_KEYWORDS, NULL},
31937 { (char *)"DateTime_FormatISOTime", (PyCFunction) _wrap_DateTime_FormatISOTime, METH_VARARGS | METH_KEYWORDS, NULL},
31938 { (char *)"DateTime_swigregister", DateTime_swigregister, METH_VARARGS, NULL},
31939 { (char *)"TimeSpan_Seconds", (PyCFunction) _wrap_TimeSpan_Seconds, METH_VARARGS | METH_KEYWORDS, NULL},
31940 { (char *)"TimeSpan_Second", (PyCFunction) _wrap_TimeSpan_Second, METH_VARARGS | METH_KEYWORDS, NULL},
31941 { (char *)"TimeSpan_Minutes", (PyCFunction) _wrap_TimeSpan_Minutes, METH_VARARGS | METH_KEYWORDS, NULL},
31942 { (char *)"TimeSpan_Minute", (PyCFunction) _wrap_TimeSpan_Minute, METH_VARARGS | METH_KEYWORDS, NULL},
31943 { (char *)"TimeSpan_Hours", (PyCFunction) _wrap_TimeSpan_Hours, METH_VARARGS | METH_KEYWORDS, NULL},
31944 { (char *)"TimeSpan_Hour", (PyCFunction) _wrap_TimeSpan_Hour, METH_VARARGS | METH_KEYWORDS, NULL},
31945 { (char *)"TimeSpan_Days", (PyCFunction) _wrap_TimeSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31946 { (char *)"TimeSpan_Day", (PyCFunction) _wrap_TimeSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31947 { (char *)"TimeSpan_Weeks", (PyCFunction) _wrap_TimeSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31948 { (char *)"TimeSpan_Week", (PyCFunction) _wrap_TimeSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31949 { (char *)"new_TimeSpan", (PyCFunction) _wrap_new_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31950 { (char *)"delete_TimeSpan", (PyCFunction) _wrap_delete_TimeSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31951 { (char *)"TimeSpan_Add", (PyCFunction) _wrap_TimeSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
31952 { (char *)"TimeSpan_Subtract", (PyCFunction) _wrap_TimeSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
31953 { (char *)"TimeSpan_Multiply", (PyCFunction) _wrap_TimeSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
31954 { (char *)"TimeSpan_Neg", (PyCFunction) _wrap_TimeSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
31955 { (char *)"TimeSpan_Abs", (PyCFunction) _wrap_TimeSpan_Abs, METH_VARARGS | METH_KEYWORDS, NULL},
31956 { (char *)"TimeSpan___iadd__", (PyCFunction) _wrap_TimeSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
31957 { (char *)"TimeSpan___isub__", (PyCFunction) _wrap_TimeSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
31958 { (char *)"TimeSpan___imul__", (PyCFunction) _wrap_TimeSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
31959 { (char *)"TimeSpan___neg__", (PyCFunction) _wrap_TimeSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
31960 { (char *)"TimeSpan___add__", (PyCFunction) _wrap_TimeSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
31961 { (char *)"TimeSpan___sub__", (PyCFunction) _wrap_TimeSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
31962 { (char *)"TimeSpan___mul__", (PyCFunction) _wrap_TimeSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
31963 { (char *)"TimeSpan___rmul__", (PyCFunction) _wrap_TimeSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
31964 { (char *)"TimeSpan___lt__", (PyCFunction) _wrap_TimeSpan___lt__, METH_VARARGS | METH_KEYWORDS, NULL},
31965 { (char *)"TimeSpan___le__", (PyCFunction) _wrap_TimeSpan___le__, METH_VARARGS | METH_KEYWORDS, NULL},
31966 { (char *)"TimeSpan___gt__", (PyCFunction) _wrap_TimeSpan___gt__, METH_VARARGS | METH_KEYWORDS, NULL},
31967 { (char *)"TimeSpan___ge__", (PyCFunction) _wrap_TimeSpan___ge__, METH_VARARGS | METH_KEYWORDS, NULL},
31968 { (char *)"TimeSpan___eq__", (PyCFunction) _wrap_TimeSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
31969 { (char *)"TimeSpan___ne__", (PyCFunction) _wrap_TimeSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
31970 { (char *)"TimeSpan_IsNull", (PyCFunction) _wrap_TimeSpan_IsNull, METH_VARARGS | METH_KEYWORDS, NULL},
31971 { (char *)"TimeSpan_IsPositive", (PyCFunction) _wrap_TimeSpan_IsPositive, METH_VARARGS | METH_KEYWORDS, NULL},
31972 { (char *)"TimeSpan_IsNegative", (PyCFunction) _wrap_TimeSpan_IsNegative, METH_VARARGS | METH_KEYWORDS, NULL},
31973 { (char *)"TimeSpan_IsEqualTo", (PyCFunction) _wrap_TimeSpan_IsEqualTo, METH_VARARGS | METH_KEYWORDS, NULL},
31974 { (char *)"TimeSpan_IsLongerThan", (PyCFunction) _wrap_TimeSpan_IsLongerThan, METH_VARARGS | METH_KEYWORDS, NULL},
31975 { (char *)"TimeSpan_IsShorterThan", (PyCFunction) _wrap_TimeSpan_IsShorterThan, METH_VARARGS | METH_KEYWORDS, NULL},
31976 { (char *)"TimeSpan_GetWeeks", (PyCFunction) _wrap_TimeSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31977 { (char *)"TimeSpan_GetDays", (PyCFunction) _wrap_TimeSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31978 { (char *)"TimeSpan_GetHours", (PyCFunction) _wrap_TimeSpan_GetHours, METH_VARARGS | METH_KEYWORDS, NULL},
31979 { (char *)"TimeSpan_GetMinutes", (PyCFunction) _wrap_TimeSpan_GetMinutes, METH_VARARGS | METH_KEYWORDS, NULL},
31980 { (char *)"TimeSpan_GetSeconds", (PyCFunction) _wrap_TimeSpan_GetSeconds, METH_VARARGS | METH_KEYWORDS, NULL},
31981 { (char *)"TimeSpan_GetMilliseconds", (PyCFunction) _wrap_TimeSpan_GetMilliseconds, METH_VARARGS | METH_KEYWORDS, NULL},
31982 { (char *)"TimeSpan_Format", (PyCFunction) _wrap_TimeSpan_Format, METH_VARARGS | METH_KEYWORDS, NULL},
31983 { (char *)"TimeSpan_swigregister", TimeSpan_swigregister, METH_VARARGS, NULL},
31984 { (char *)"new_DateSpan", (PyCFunction) _wrap_new_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31985 { (char *)"delete_DateSpan", (PyCFunction) _wrap_delete_DateSpan, METH_VARARGS | METH_KEYWORDS, NULL},
31986 { (char *)"DateSpan_Days", (PyCFunction) _wrap_DateSpan_Days, METH_VARARGS | METH_KEYWORDS, NULL},
31987 { (char *)"DateSpan_Day", (PyCFunction) _wrap_DateSpan_Day, METH_VARARGS | METH_KEYWORDS, NULL},
31988 { (char *)"DateSpan_Weeks", (PyCFunction) _wrap_DateSpan_Weeks, METH_VARARGS | METH_KEYWORDS, NULL},
31989 { (char *)"DateSpan_Week", (PyCFunction) _wrap_DateSpan_Week, METH_VARARGS | METH_KEYWORDS, NULL},
31990 { (char *)"DateSpan_Months", (PyCFunction) _wrap_DateSpan_Months, METH_VARARGS | METH_KEYWORDS, NULL},
31991 { (char *)"DateSpan_Month", (PyCFunction) _wrap_DateSpan_Month, METH_VARARGS | METH_KEYWORDS, NULL},
31992 { (char *)"DateSpan_Years", (PyCFunction) _wrap_DateSpan_Years, METH_VARARGS | METH_KEYWORDS, NULL},
31993 { (char *)"DateSpan_Year", (PyCFunction) _wrap_DateSpan_Year, METH_VARARGS | METH_KEYWORDS, NULL},
31994 { (char *)"DateSpan_SetYears", (PyCFunction) _wrap_DateSpan_SetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31995 { (char *)"DateSpan_SetMonths", (PyCFunction) _wrap_DateSpan_SetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
31996 { (char *)"DateSpan_SetWeeks", (PyCFunction) _wrap_DateSpan_SetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
31997 { (char *)"DateSpan_SetDays", (PyCFunction) _wrap_DateSpan_SetDays, METH_VARARGS | METH_KEYWORDS, NULL},
31998 { (char *)"DateSpan_GetYears", (PyCFunction) _wrap_DateSpan_GetYears, METH_VARARGS | METH_KEYWORDS, NULL},
31999 { (char *)"DateSpan_GetMonths", (PyCFunction) _wrap_DateSpan_GetMonths, METH_VARARGS | METH_KEYWORDS, NULL},
32000 { (char *)"DateSpan_GetWeeks", (PyCFunction) _wrap_DateSpan_GetWeeks, METH_VARARGS | METH_KEYWORDS, NULL},
32001 { (char *)"DateSpan_GetDays", (PyCFunction) _wrap_DateSpan_GetDays, METH_VARARGS | METH_KEYWORDS, NULL},
32002 { (char *)"DateSpan_GetTotalDays", (PyCFunction) _wrap_DateSpan_GetTotalDays, METH_VARARGS | METH_KEYWORDS, NULL},
32003 { (char *)"DateSpan_Add", (PyCFunction) _wrap_DateSpan_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32004 { (char *)"DateSpan_Subtract", (PyCFunction) _wrap_DateSpan_Subtract, METH_VARARGS | METH_KEYWORDS, NULL},
32005 { (char *)"DateSpan_Neg", (PyCFunction) _wrap_DateSpan_Neg, METH_VARARGS | METH_KEYWORDS, NULL},
32006 { (char *)"DateSpan_Multiply", (PyCFunction) _wrap_DateSpan_Multiply, METH_VARARGS | METH_KEYWORDS, NULL},
32007 { (char *)"DateSpan___iadd__", (PyCFunction) _wrap_DateSpan___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
32008 { (char *)"DateSpan___isub__", (PyCFunction) _wrap_DateSpan___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
32009 { (char *)"DateSpan___neg__", (PyCFunction) _wrap_DateSpan___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
32010 { (char *)"DateSpan___imul__", (PyCFunction) _wrap_DateSpan___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
32011 { (char *)"DateSpan___add__", (PyCFunction) _wrap_DateSpan___add__, METH_VARARGS | METH_KEYWORDS, NULL},
32012 { (char *)"DateSpan___sub__", (PyCFunction) _wrap_DateSpan___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
32013 { (char *)"DateSpan___mul__", (PyCFunction) _wrap_DateSpan___mul__, METH_VARARGS | METH_KEYWORDS, NULL},
32014 { (char *)"DateSpan___rmul__", (PyCFunction) _wrap_DateSpan___rmul__, METH_VARARGS | METH_KEYWORDS, NULL},
32015 { (char *)"DateSpan___eq__", (PyCFunction) _wrap_DateSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32016 { (char *)"DateSpan___ne__", (PyCFunction) _wrap_DateSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32017 { (char *)"DateSpan_swigregister", DateSpan_swigregister, METH_VARARGS, NULL},
32018 { (char *)"GetLocalTime", (PyCFunction) _wrap_GetLocalTime, METH_VARARGS | METH_KEYWORDS, NULL},
32019 { (char *)"GetUTCTime", (PyCFunction) _wrap_GetUTCTime, METH_VARARGS | METH_KEYWORDS, NULL},
32020 { (char *)"GetCurrentTime", (PyCFunction) _wrap_GetCurrentTime, METH_VARARGS | METH_KEYWORDS, NULL},
32021 { (char *)"GetLocalTimeMillis", (PyCFunction) _wrap_GetLocalTimeMillis, METH_VARARGS | METH_KEYWORDS, NULL},
32022 { (char *)"new_DataFormat", (PyCFunction) _wrap_new_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32023 { (char *)"new_CustomDataFormat", (PyCFunction) _wrap_new_CustomDataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32024 { (char *)"delete_DataFormat", (PyCFunction) _wrap_delete_DataFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32025 { (char *)"DataFormat___eq__", _wrap_DataFormat___eq__, METH_VARARGS, NULL},
32026 { (char *)"DataFormat___ne__", _wrap_DataFormat___ne__, METH_VARARGS, NULL},
32027 { (char *)"DataFormat_SetType", (PyCFunction) _wrap_DataFormat_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
32028 { (char *)"DataFormat_GetType", (PyCFunction) _wrap_DataFormat_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
32029 { (char *)"DataFormat_GetId", (PyCFunction) _wrap_DataFormat_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
32030 { (char *)"DataFormat_SetId", (PyCFunction) _wrap_DataFormat_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
32031 { (char *)"DataFormat_swigregister", DataFormat_swigregister, METH_VARARGS, NULL},
32032 { (char *)"delete_DataObject", (PyCFunction) _wrap_delete_DataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32033 { (char *)"DataObject_GetPreferredFormat", (PyCFunction) _wrap_DataObject_GetPreferredFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32034 { (char *)"DataObject_GetFormatCount", (PyCFunction) _wrap_DataObject_GetFormatCount, METH_VARARGS | METH_KEYWORDS, NULL},
32035 { (char *)"DataObject_IsSupported", (PyCFunction) _wrap_DataObject_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32036 { (char *)"DataObject_GetDataSize", (PyCFunction) _wrap_DataObject_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32037 { (char *)"DataObject_GetAllFormats", (PyCFunction) _wrap_DataObject_GetAllFormats, METH_VARARGS | METH_KEYWORDS, NULL},
32038 { (char *)"DataObject_GetDataHere", (PyCFunction) _wrap_DataObject_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32039 { (char *)"DataObject_SetData", (PyCFunction) _wrap_DataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32040 { (char *)"DataObject_swigregister", DataObject_swigregister, METH_VARARGS, NULL},
32041 { (char *)"new_DataObjectSimple", (PyCFunction) _wrap_new_DataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32042 { (char *)"DataObjectSimple_GetFormat", (PyCFunction) _wrap_DataObjectSimple_GetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32043 { (char *)"DataObjectSimple_SetFormat", (PyCFunction) _wrap_DataObjectSimple_SetFormat, METH_VARARGS | METH_KEYWORDS, NULL},
32044 { (char *)"DataObjectSimple_GetDataSize", (PyCFunction) _wrap_DataObjectSimple_GetDataSize, METH_VARARGS | METH_KEYWORDS, NULL},
32045 { (char *)"DataObjectSimple_GetDataHere", (PyCFunction) _wrap_DataObjectSimple_GetDataHere, METH_VARARGS | METH_KEYWORDS, NULL},
32046 { (char *)"DataObjectSimple_SetData", (PyCFunction) _wrap_DataObjectSimple_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32047 { (char *)"DataObjectSimple_swigregister", DataObjectSimple_swigregister, METH_VARARGS, NULL},
32048 { (char *)"new_PyDataObjectSimple", (PyCFunction) _wrap_new_PyDataObjectSimple, METH_VARARGS | METH_KEYWORDS, NULL},
32049 { (char *)"PyDataObjectSimple__setCallbackInfo", (PyCFunction) _wrap_PyDataObjectSimple__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32050 { (char *)"PyDataObjectSimple_swigregister", PyDataObjectSimple_swigregister, METH_VARARGS, NULL},
32051 { (char *)"new_DataObjectComposite", (PyCFunction) _wrap_new_DataObjectComposite, METH_VARARGS | METH_KEYWORDS, NULL},
32052 { (char *)"DataObjectComposite_Add", (PyCFunction) _wrap_DataObjectComposite_Add, METH_VARARGS | METH_KEYWORDS, NULL},
32053 { (char *)"DataObjectComposite_swigregister", DataObjectComposite_swigregister, METH_VARARGS, NULL},
32054 { (char *)"new_TextDataObject", (PyCFunction) _wrap_new_TextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32055 { (char *)"TextDataObject_GetTextLength", (PyCFunction) _wrap_TextDataObject_GetTextLength, METH_VARARGS | METH_KEYWORDS, NULL},
32056 { (char *)"TextDataObject_GetText", (PyCFunction) _wrap_TextDataObject_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
32057 { (char *)"TextDataObject_SetText", (PyCFunction) _wrap_TextDataObject_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
32058 { (char *)"TextDataObject_swigregister", TextDataObject_swigregister, METH_VARARGS, NULL},
32059 { (char *)"new_PyTextDataObject", (PyCFunction) _wrap_new_PyTextDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32060 { (char *)"PyTextDataObject__setCallbackInfo", (PyCFunction) _wrap_PyTextDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32061 { (char *)"PyTextDataObject_swigregister", PyTextDataObject_swigregister, METH_VARARGS, NULL},
32062 { (char *)"new_BitmapDataObject", (PyCFunction) _wrap_new_BitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32063 { (char *)"BitmapDataObject_GetBitmap", (PyCFunction) _wrap_BitmapDataObject_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32064 { (char *)"BitmapDataObject_SetBitmap", (PyCFunction) _wrap_BitmapDataObject_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
32065 { (char *)"BitmapDataObject_swigregister", BitmapDataObject_swigregister, METH_VARARGS, NULL},
32066 { (char *)"new_PyBitmapDataObject", (PyCFunction) _wrap_new_PyBitmapDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32067 { (char *)"PyBitmapDataObject__setCallbackInfo", (PyCFunction) _wrap_PyBitmapDataObject__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32068 { (char *)"PyBitmapDataObject_swigregister", PyBitmapDataObject_swigregister, METH_VARARGS, NULL},
32069 { (char *)"new_FileDataObject", (PyCFunction) _wrap_new_FileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32070 { (char *)"FileDataObject_GetFilenames", (PyCFunction) _wrap_FileDataObject_GetFilenames, METH_VARARGS | METH_KEYWORDS, NULL},
32071 { (char *)"FileDataObject_AddFile", (PyCFunction) _wrap_FileDataObject_AddFile, METH_VARARGS | METH_KEYWORDS, NULL},
32072 { (char *)"FileDataObject_swigregister", FileDataObject_swigregister, METH_VARARGS, NULL},
32073 { (char *)"new_CustomDataObject", _wrap_new_CustomDataObject, METH_VARARGS, NULL},
32074 { (char *)"CustomDataObject_SetData", (PyCFunction) _wrap_CustomDataObject_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32075 { (char *)"CustomDataObject_GetSize", (PyCFunction) _wrap_CustomDataObject_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
32076 { (char *)"CustomDataObject_GetData", (PyCFunction) _wrap_CustomDataObject_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32077 { (char *)"CustomDataObject_swigregister", CustomDataObject_swigregister, METH_VARARGS, NULL},
32078 { (char *)"new_URLDataObject", (PyCFunction) _wrap_new_URLDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32079 { (char *)"URLDataObject_GetURL", (PyCFunction) _wrap_URLDataObject_GetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32080 { (char *)"URLDataObject_SetURL", (PyCFunction) _wrap_URLDataObject_SetURL, METH_VARARGS | METH_KEYWORDS, NULL},
32081 { (char *)"URLDataObject_swigregister", URLDataObject_swigregister, METH_VARARGS, NULL},
32082 { (char *)"new_MetafileDataObject", (PyCFunction) _wrap_new_MetafileDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32083 { (char *)"MetafileDataObject_SetMetafile", (PyCFunction) _wrap_MetafileDataObject_SetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32084 { (char *)"MetafileDataObject_GetMetafile", (PyCFunction) _wrap_MetafileDataObject_GetMetafile, METH_VARARGS | METH_KEYWORDS, NULL},
32085 { (char *)"MetafileDataObject_swigregister", MetafileDataObject_swigregister, METH_VARARGS, NULL},
32086 { (char *)"IsDragResultOk", (PyCFunction) _wrap_IsDragResultOk, METH_VARARGS | METH_KEYWORDS, NULL},
32087 { (char *)"new_DropSource", (PyCFunction) _wrap_new_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32088 { (char *)"DropSource__setCallbackInfo", (PyCFunction) _wrap_DropSource__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32089 { (char *)"delete_DropSource", (PyCFunction) _wrap_delete_DropSource, METH_VARARGS | METH_KEYWORDS, NULL},
32090 { (char *)"DropSource_SetData", (PyCFunction) _wrap_DropSource_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32091 { (char *)"DropSource_GetDataObject", (PyCFunction) _wrap_DropSource_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32092 { (char *)"DropSource_SetCursor", (PyCFunction) _wrap_DropSource_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
32093 { (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32094 { (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS, NULL},
32095 { (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS, NULL},
32096 { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32097 { (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32098 { (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32099 { (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32100 { (char *)"DropTarget_SetDataObject", (PyCFunction) _wrap_DropTarget_SetDataObject, METH_VARARGS | METH_KEYWORDS, NULL},
32101 { (char *)"DropTarget_base_OnEnter", (PyCFunction) _wrap_DropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32102 { (char *)"DropTarget_base_OnDragOver", (PyCFunction) _wrap_DropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32103 { (char *)"DropTarget_base_OnLeave", (PyCFunction) _wrap_DropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32104 { (char *)"DropTarget_base_OnDrop", (PyCFunction) _wrap_DropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32105 { (char *)"DropTarget_GetData", (PyCFunction) _wrap_DropTarget_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32106 { (char *)"DropTarget_swigregister", DropTarget_swigregister, METH_VARARGS, NULL},
32107 { (char *)"new_TextDropTarget", (PyCFunction) _wrap_new_TextDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32108 { (char *)"TextDropTarget__setCallbackInfo", (PyCFunction) _wrap_TextDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32109 { (char *)"TextDropTarget_base_OnEnter", (PyCFunction) _wrap_TextDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32110 { (char *)"TextDropTarget_base_OnDragOver", (PyCFunction) _wrap_TextDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32111 { (char *)"TextDropTarget_base_OnLeave", (PyCFunction) _wrap_TextDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32112 { (char *)"TextDropTarget_base_OnDrop", (PyCFunction) _wrap_TextDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32113 { (char *)"TextDropTarget_base_OnData", (PyCFunction) _wrap_TextDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32114 { (char *)"TextDropTarget_swigregister", TextDropTarget_swigregister, METH_VARARGS, NULL},
32115 { (char *)"new_FileDropTarget", (PyCFunction) _wrap_new_FileDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
32116 { (char *)"FileDropTarget__setCallbackInfo", (PyCFunction) _wrap_FileDropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
32117 { (char *)"FileDropTarget_base_OnEnter", (PyCFunction) _wrap_FileDropTarget_base_OnEnter, METH_VARARGS | METH_KEYWORDS, NULL},
32118 { (char *)"FileDropTarget_base_OnDragOver", (PyCFunction) _wrap_FileDropTarget_base_OnDragOver, METH_VARARGS | METH_KEYWORDS, NULL},
32119 { (char *)"FileDropTarget_base_OnLeave", (PyCFunction) _wrap_FileDropTarget_base_OnLeave, METH_VARARGS | METH_KEYWORDS, NULL},
32120 { (char *)"FileDropTarget_base_OnDrop", (PyCFunction) _wrap_FileDropTarget_base_OnDrop, METH_VARARGS | METH_KEYWORDS, NULL},
32121 { (char *)"FileDropTarget_base_OnData", (PyCFunction) _wrap_FileDropTarget_base_OnData, METH_VARARGS | METH_KEYWORDS, NULL},
32122 { (char *)"FileDropTarget_swigregister", FileDropTarget_swigregister, METH_VARARGS, NULL},
32123 { (char *)"new_Clipboard", (PyCFunction) _wrap_new_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32124 { (char *)"delete_Clipboard", (PyCFunction) _wrap_delete_Clipboard, METH_VARARGS | METH_KEYWORDS, NULL},
32125 { (char *)"Clipboard_Open", (PyCFunction) _wrap_Clipboard_Open, METH_VARARGS | METH_KEYWORDS, NULL},
32126 { (char *)"Clipboard_Close", (PyCFunction) _wrap_Clipboard_Close, METH_VARARGS | METH_KEYWORDS, NULL},
32127 { (char *)"Clipboard_IsOpened", (PyCFunction) _wrap_Clipboard_IsOpened, METH_VARARGS | METH_KEYWORDS, NULL},
32128 { (char *)"Clipboard_AddData", (PyCFunction) _wrap_Clipboard_AddData, METH_VARARGS | METH_KEYWORDS, NULL},
32129 { (char *)"Clipboard_SetData", (PyCFunction) _wrap_Clipboard_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
32130 { (char *)"Clipboard_IsSupported", (PyCFunction) _wrap_Clipboard_IsSupported, METH_VARARGS | METH_KEYWORDS, NULL},
32131 { (char *)"Clipboard_GetData", (PyCFunction) _wrap_Clipboard_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
32132 { (char *)"Clipboard_Clear", (PyCFunction) _wrap_Clipboard_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
32133 { (char *)"Clipboard_Flush", (PyCFunction) _wrap_Clipboard_Flush, METH_VARARGS | METH_KEYWORDS, NULL},
32134 { (char *)"Clipboard_UsePrimarySelection", (PyCFunction) _wrap_Clipboard_UsePrimarySelection, METH_VARARGS | METH_KEYWORDS, NULL},
32135 { (char *)"Clipboard_Get", (PyCFunction) _wrap_Clipboard_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32136 { (char *)"Clipboard_swigregister", Clipboard_swigregister, METH_VARARGS, NULL},
32137 { (char *)"new_ClipboardLocker", (PyCFunction) _wrap_new_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32138 { (char *)"delete_ClipboardLocker", (PyCFunction) _wrap_delete_ClipboardLocker, METH_VARARGS | METH_KEYWORDS, NULL},
32139 { (char *)"ClipboardLocker___nonzero__", (PyCFunction) _wrap_ClipboardLocker___nonzero__, METH_VARARGS | METH_KEYWORDS, NULL},
32140 { (char *)"ClipboardLocker_swigregister", ClipboardLocker_swigregister, METH_VARARGS, NULL},
32141 { (char *)"new_VideoMode", (PyCFunction) _wrap_new_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32142 { (char *)"delete_VideoMode", (PyCFunction) _wrap_delete_VideoMode, METH_VARARGS | METH_KEYWORDS, NULL},
32143 { (char *)"VideoMode_Matches", (PyCFunction) _wrap_VideoMode_Matches, METH_VARARGS | METH_KEYWORDS, NULL},
32144 { (char *)"VideoMode_GetWidth", (PyCFunction) _wrap_VideoMode_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
32145 { (char *)"VideoMode_GetHeight", (PyCFunction) _wrap_VideoMode_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
32146 { (char *)"VideoMode_GetDepth", (PyCFunction) _wrap_VideoMode_GetDepth, METH_VARARGS | METH_KEYWORDS, NULL},
32147 { (char *)"VideoMode_IsOk", (PyCFunction) _wrap_VideoMode_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32148 { (char *)"VideoMode___eq__", (PyCFunction) _wrap_VideoMode___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
32149 { (char *)"VideoMode___ne__", (PyCFunction) _wrap_VideoMode___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
32150 { (char *)"VideoMode_w_set", (PyCFunction) _wrap_VideoMode_w_set, METH_VARARGS | METH_KEYWORDS, NULL},
32151 { (char *)"VideoMode_w_get", (PyCFunction) _wrap_VideoMode_w_get, METH_VARARGS | METH_KEYWORDS, NULL},
32152 { (char *)"VideoMode_h_set", (PyCFunction) _wrap_VideoMode_h_set, METH_VARARGS | METH_KEYWORDS, NULL},
32153 { (char *)"VideoMode_h_get", (PyCFunction) _wrap_VideoMode_h_get, METH_VARARGS | METH_KEYWORDS, NULL},
32154 { (char *)"VideoMode_bpp_set", (PyCFunction) _wrap_VideoMode_bpp_set, METH_VARARGS | METH_KEYWORDS, NULL},
32155 { (char *)"VideoMode_bpp_get", (PyCFunction) _wrap_VideoMode_bpp_get, METH_VARARGS | METH_KEYWORDS, NULL},
32156 { (char *)"VideoMode_refresh_set", (PyCFunction) _wrap_VideoMode_refresh_set, METH_VARARGS | METH_KEYWORDS, NULL},
32157 { (char *)"VideoMode_refresh_get", (PyCFunction) _wrap_VideoMode_refresh_get, METH_VARARGS | METH_KEYWORDS, NULL},
32158 { (char *)"VideoMode_swigregister", VideoMode_swigregister, METH_VARARGS, NULL},
32159 { (char *)"new_Display", (PyCFunction) _wrap_new_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32160 { (char *)"delete_Display", (PyCFunction) _wrap_delete_Display, METH_VARARGS | METH_KEYWORDS, NULL},
32161 { (char *)"Display_GetCount", (PyCFunction) _wrap_Display_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
32162 { (char *)"Display_GetFromPoint", (PyCFunction) _wrap_Display_GetFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
32163 { (char *)"Display_GetFromWindow", (PyCFunction) _wrap_Display_GetFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
32164 { (char *)"Display_IsOk", (PyCFunction) _wrap_Display_IsOk, METH_VARARGS | METH_KEYWORDS, NULL},
32165 { (char *)"Display_GetGeometry", (PyCFunction) _wrap_Display_GetGeometry, METH_VARARGS | METH_KEYWORDS, NULL},
32166 { (char *)"Display_GetName", (PyCFunction) _wrap_Display_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
32167 { (char *)"Display_IsPrimary", (PyCFunction) _wrap_Display_IsPrimary, METH_VARARGS | METH_KEYWORDS, NULL},
32168 { (char *)"Display_GetModes", (PyCFunction) _wrap_Display_GetModes, METH_VARARGS | METH_KEYWORDS, NULL},
32169 { (char *)"Display_GetCurrentMode", (PyCFunction) _wrap_Display_GetCurrentMode, METH_VARARGS | METH_KEYWORDS, NULL},
32170 { (char *)"Display_ChangeMode", (PyCFunction) _wrap_Display_ChangeMode, METH_VARARGS | METH_KEYWORDS, NULL},
32171 { (char *)"Display_ResetMode", (PyCFunction) _wrap_Display_ResetMode, METH_VARARGS | METH_KEYWORDS, NULL},
32172 { (char *)"Display_swigregister", Display_swigregister, METH_VARARGS, NULL},
32173 { (char *)"StandardPaths_Get", (PyCFunction) _wrap_StandardPaths_Get, METH_VARARGS | METH_KEYWORDS, NULL},
32174 { (char *)"StandardPaths_GetConfigDir", (PyCFunction) _wrap_StandardPaths_GetConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32175 { (char *)"StandardPaths_GetUserConfigDir", (PyCFunction) _wrap_StandardPaths_GetUserConfigDir, METH_VARARGS | METH_KEYWORDS, NULL},
32176 { (char *)"StandardPaths_GetDataDir", (PyCFunction) _wrap_StandardPaths_GetDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32177 { (char *)"StandardPaths_GetLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32178 { (char *)"StandardPaths_GetUserDataDir", (PyCFunction) _wrap_StandardPaths_GetUserDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32179 { (char *)"StandardPaths_GetUserLocalDataDir", (PyCFunction) _wrap_StandardPaths_GetUserLocalDataDir, METH_VARARGS | METH_KEYWORDS, NULL},
32180 { (char *)"StandardPaths_GetPluginsDir", (PyCFunction) _wrap_StandardPaths_GetPluginsDir, METH_VARARGS | METH_KEYWORDS, NULL},
32181 { (char *)"StandardPaths_SetInstallPrefix", (PyCFunction) _wrap_StandardPaths_SetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32182 { (char *)"StandardPaths_GetInstallPrefix", (PyCFunction) _wrap_StandardPaths_GetInstallPrefix, METH_VARARGS | METH_KEYWORDS, NULL},
32183 { (char *)"StandardPaths_swigregister", StandardPaths_swigregister, METH_VARARGS, NULL},
32184 { NULL, NULL, 0, NULL }
32185 };
32186
32187
32188 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
32189
32190 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
32191 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
32192 }
32193 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
32194 return (void *)((wxEvent *) ((wxMenuEvent *) x));
32195 }
32196 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
32197 return (void *)((wxEvent *) ((wxCloseEvent *) x));
32198 }
32199 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
32200 return (void *)((wxEvent *) ((wxMouseEvent *) x));
32201 }
32202 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
32203 return (void *)((wxEvent *) ((wxEraseEvent *) x));
32204 }
32205 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
32206 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
32207 }
32208 static void *_p_wxTimerEventTo_p_wxEvent(void *x) {
32209 return (void *)((wxEvent *) ((wxTimerEvent *) x));
32210 }
32211 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
32212 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
32213 }
32214 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
32215 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
32216 }
32217 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
32218 return (void *)((wxEvent *) ((wxPyEvent *) x));
32219 }
32220 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
32221 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
32222 }
32223 static void *_p_wxJoystickEventTo_p_wxEvent(void *x) {
32224 return (void *)((wxEvent *) ((wxJoystickEvent *) x));
32225 }
32226 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
32227 return (void *)((wxEvent *) ((wxIdleEvent *) x));
32228 }
32229 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
32230 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
32231 }
32232 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
32233 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
32234 }
32235 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
32236 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
32237 }
32238 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
32239 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
32240 }
32241 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
32242 return (void *)((wxEvent *) ((wxActivateEvent *) x));
32243 }
32244 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
32245 return (void *)((wxEvent *) ((wxSizeEvent *) x));
32246 }
32247 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
32248 return (void *)((wxEvent *) ((wxMoveEvent *) x));
32249 }
32250 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
32251 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
32252 }
32253 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
32254 return (void *)((wxEvent *) ((wxPaintEvent *) x));
32255 }
32256 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
32257 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
32258 }
32259 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
32260 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
32261 }
32262 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
32263 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
32264 }
32265 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
32266 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
32267 }
32268 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
32269 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32270 }
32271 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
32272 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
32273 }
32274 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
32275 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
32276 }
32277 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
32278 return (void *)((wxEvent *) ((wxFocusEvent *) x));
32279 }
32280 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
32281 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
32282 }
32283 static void *_p_wxProcessEventTo_p_wxEvent(void *x) {
32284 return (void *)((wxEvent *) ((wxProcessEvent *) x));
32285 }
32286 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
32287 return (void *)((wxEvent *) ((wxShowEvent *) x));
32288 }
32289 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
32290 return (void *)((wxEvent *) ((wxCommandEvent *) x));
32291 }
32292 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
32293 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
32294 }
32295 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
32296 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32297 }
32298 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
32299 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
32300 }
32301 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
32302 return (void *)((wxEvent *) ((wxKeyEvent *) x));
32303 }
32304 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
32305 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
32306 }
32307 static void *_p_wxFileConfigTo_p_wxConfigBase(void *x) {
32308 return (void *)((wxConfigBase *) ((wxFileConfig *) x));
32309 }
32310 static void *_p_wxConfigTo_p_wxConfigBase(void *x) {
32311 return (void *)((wxConfigBase *) ((wxConfig *) x));
32312 }
32313 static void *_p_wxPyBitmapDataObjectTo_p_wxBitmapDataObject(void *x) {
32314 return (void *)((wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32315 }
32316 static void *_p_wxPyTextDataObjectTo_p_wxTextDataObject(void *x) {
32317 return (void *)((wxTextDataObject *) ((wxPyTextDataObject *) x));
32318 }
32319 static void *_p_wxDataObjectSimpleTo_p_wxDataObject(void *x) {
32320 return (void *)((wxDataObject *) ((wxDataObjectSimple *) x));
32321 }
32322 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObject(void *x) {
32323 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32324 }
32325 static void *_p_wxDataObjectCompositeTo_p_wxDataObject(void *x) {
32326 return (void *)((wxDataObject *) ((wxDataObjectComposite *) x));
32327 }
32328 static void *_p_wxTextDataObjectTo_p_wxDataObject(void *x) {
32329 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxTextDataObject *) x));
32330 }
32331 static void *_p_wxPyTextDataObjectTo_p_wxDataObject(void *x) {
32332 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxTextDataObject *) ((wxPyTextDataObject *) x));
32333 }
32334 static void *_p_wxBitmapDataObjectTo_p_wxDataObject(void *x) {
32335 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32336 }
32337 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObject(void *x) {
32338 return (void *)((wxDataObject *) (wxDataObjectSimple *)(wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32339 }
32340 static void *_p_wxFileDataObjectTo_p_wxDataObject(void *x) {
32341 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxFileDataObject *) x));
32342 }
32343 static void *_p_wxCustomDataObjectTo_p_wxDataObject(void *x) {
32344 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxCustomDataObject *) x));
32345 }
32346 static void *_p_wxURLDataObjectTo_p_wxDataObject(void *x) {
32347 return (void *)((wxDataObject *) (wxDataObjectComposite *) ((wxURLDataObject *) x));
32348 }
32349 static void *_p_wxMetafileDataObjectTo_p_wxDataObject(void *x) {
32350 return (void *)((wxDataObject *) (wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32351 }
32352 static void *_p_wxURLDataObjectTo_p_wxDataObjectComposite(void *x) {
32353 return (void *)((wxDataObjectComposite *) ((wxURLDataObject *) x));
32354 }
32355 static void *_p_wxPyDataObjectSimpleTo_p_wxDataObjectSimple(void *x) {
32356 return (void *)((wxDataObjectSimple *) ((wxPyDataObjectSimple *) x));
32357 }
32358 static void *_p_wxTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32359 return (void *)((wxDataObjectSimple *) ((wxTextDataObject *) x));
32360 }
32361 static void *_p_wxPyTextDataObjectTo_p_wxDataObjectSimple(void *x) {
32362 return (void *)((wxDataObjectSimple *) (wxTextDataObject *) ((wxPyTextDataObject *) x));
32363 }
32364 static void *_p_wxBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32365 return (void *)((wxDataObjectSimple *) ((wxBitmapDataObject *) x));
32366 }
32367 static void *_p_wxPyBitmapDataObjectTo_p_wxDataObjectSimple(void *x) {
32368 return (void *)((wxDataObjectSimple *) (wxBitmapDataObject *) ((wxPyBitmapDataObject *) x));
32369 }
32370 static void *_p_wxFileDataObjectTo_p_wxDataObjectSimple(void *x) {
32371 return (void *)((wxDataObjectSimple *) ((wxFileDataObject *) x));
32372 }
32373 static void *_p_wxCustomDataObjectTo_p_wxDataObjectSimple(void *x) {
32374 return (void *)((wxDataObjectSimple *) ((wxCustomDataObject *) x));
32375 }
32376 static void *_p_wxMetafileDataObjectTo_p_wxDataObjectSimple(void *x) {
32377 return (void *)((wxDataObjectSimple *) ((wxMetafileDataObject *) x));
32378 }
32379 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
32380 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
32381 }
32382 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
32383 return (void *)((wxEvtHandler *) ((wxWindow *) x));
32384 }
32385 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
32386 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32387 }
32388 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
32389 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
32390 }
32391 static void *_p_wxPyTimerTo_p_wxEvtHandler(void *x) {
32392 return (void *)((wxEvtHandler *) ((wxPyTimer *) x));
32393 }
32394 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
32395 return (void *)((wxEvtHandler *) ((wxValidator *) x));
32396 }
32397 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
32398 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
32399 }
32400 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
32401 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
32402 }
32403 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
32404 return (void *)((wxEvtHandler *) ((wxMenu *) x));
32405 }
32406 static void *_p_wxPyProcessTo_p_wxEvtHandler(void *x) {
32407 return (void *)((wxEvtHandler *) ((wxPyProcess *) x));
32408 }
32409 static void *_p_wxPyTipProviderTo_p_wxTipProvider(void *x) {
32410 return (void *)((wxTipProvider *) ((wxPyTipProvider *) x));
32411 }
32412 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
32413 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
32414 }
32415 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
32416 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
32417 }
32418 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
32419 return (void *)((wxObject *) ((wxSizerItem *) x));
32420 }
32421 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
32422 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
32423 }
32424 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
32425 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
32426 }
32427 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
32428 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
32429 }
32430 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
32431 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
32432 }
32433 static void *_p_wxSizerTo_p_wxObject(void *x) {
32434 return (void *)((wxObject *) ((wxSizer *) x));
32435 }
32436 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
32437 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
32438 }
32439 static void *_p_wxFileHistoryTo_p_wxObject(void *x) {
32440 return (void *)((wxObject *) ((wxFileHistory *) x));
32441 }
32442 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
32443 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
32444 }
32445 static void *_p_wxEventTo_p_wxObject(void *x) {
32446 return (void *)((wxObject *) ((wxEvent *) x));
32447 }
32448 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
32449 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
32450 }
32451 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
32452 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
32453 }
32454 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
32455 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
32456 }
32457 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
32458 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
32459 }
32460 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
32461 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
32462 }
32463 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
32464 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
32465 }
32466 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
32467 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
32468 }
32469 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
32470 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
32471 }
32472 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
32473 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
32474 }
32475 static void *_p_wxControlTo_p_wxObject(void *x) {
32476 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
32477 }
32478 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
32479 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
32480 }
32481 static void *_p_wxTimerEventTo_p_wxObject(void *x) {
32482 return (void *)((wxObject *) (wxEvent *) ((wxTimerEvent *) x));
32483 }
32484 static void *_p_wxFSFileTo_p_wxObject(void *x) {
32485 return (void *)((wxObject *) ((wxFSFile *) x));
32486 }
32487 static void *_p_wxClipboardTo_p_wxObject(void *x) {
32488 return (void *)((wxObject *) ((wxClipboard *) x));
32489 }
32490 static void *_p_wxPySizerTo_p_wxObject(void *x) {
32491 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
32492 }
32493 static void *_p_wxPyEventTo_p_wxObject(void *x) {
32494 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
32495 }
32496 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
32497 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
32498 }
32499 static void *_p_wxShowEventTo_p_wxObject(void *x) {
32500 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
32501 }
32502 static void *_p_wxToolTipTo_p_wxObject(void *x) {
32503 return (void *)((wxObject *) ((wxToolTip *) x));
32504 }
32505 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
32506 return (void *)((wxObject *) ((wxMenuItem *) x));
32507 }
32508 static void *_p_wxDateEventTo_p_wxObject(void *x) {
32509 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
32510 }
32511 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
32512 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
32513 }
32514 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
32515 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
32516 }
32517 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
32518 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
32519 }
32520 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
32521 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
32522 }
32523 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
32524 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
32525 }
32526 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
32527 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
32528 }
32529 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
32530 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
32531 }
32532 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
32533 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
32534 }
32535 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
32536 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
32537 }
32538 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
32539 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
32540 }
32541 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
32542 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
32543 }
32544 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
32545 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
32546 }
32547 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
32548 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
32549 }
32550 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
32551 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
32552 }
32553 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
32554 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
32555 }
32556 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
32557 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
32558 }
32559 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
32560 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
32561 }
32562 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
32563 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
32564 }
32565 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
32566 return (void *)((wxObject *) ((wxImageHandler *) x));
32567 }
32568 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
32569 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
32570 }
32571 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
32572 return (void *)((wxObject *) ((wxEvtHandler *) x));
32573 }
32574 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
32575 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
32576 }
32577 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
32578 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
32579 }
32580 static void *_p_wxImageTo_p_wxObject(void *x) {
32581 return (void *)((wxObject *) ((wxImage *) x));
32582 }
32583 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
32584 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
32585 }
32586 static void *_p_wxSystemOptionsTo_p_wxObject(void *x) {
32587 return (void *)((wxObject *) ((wxSystemOptions *) x));
32588 }
32589 static void *_p_wxJoystickEventTo_p_wxObject(void *x) {
32590 return (void *)((wxObject *) (wxEvent *) ((wxJoystickEvent *) x));
32591 }
32592 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
32593 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
32594 }
32595 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
32596 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
32597 }
32598 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
32599 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
32600 }
32601 static void *_p_wxWindowTo_p_wxObject(void *x) {
32602 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
32603 }
32604 static void *_p_wxMenuTo_p_wxObject(void *x) {
32605 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
32606 }
32607 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
32608 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
32609 }
32610 static void *_p_wxPyProcessTo_p_wxObject(void *x) {
32611 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyProcess *) x));
32612 }
32613 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
32614 return (void *)((wxObject *) ((wxFileSystem *) x));
32615 }
32616 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
32617 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
32618 }
32619 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
32620 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
32621 }
32622 static void *_p_wxPyAppTo_p_wxObject(void *x) {
32623 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
32624 }
32625 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
32626 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
32627 }
32628 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
32629 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
32630 }
32631 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
32632 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
32633 }
32634 static void *_p_wxBusyInfoTo_p_wxObject(void *x) {
32635 return (void *)((wxObject *) ((wxBusyInfo *) x));
32636 }
32637 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
32638 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
32639 }
32640 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
32641 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
32642 }
32643 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
32644 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
32645 }
32646 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
32647 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
32648 }
32649 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
32650 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
32651 }
32652 static void *_p_wxProcessEventTo_p_wxObject(void *x) {
32653 return (void *)((wxObject *) (wxEvent *) ((wxProcessEvent *) x));
32654 }
32655 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
32656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
32657 }
32658 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
32659 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
32660 }
32661 static void *_p_wxValidatorTo_p_wxObject(void *x) {
32662 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
32663 }
32664 static void *_p_wxPyTimerTo_p_wxObject(void *x) {
32665 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyTimer *) x));
32666 }
32667 static void *_p_wxLogStderrTo_p_wxLog(void *x) {
32668 return (void *)((wxLog *) ((wxLogStderr *) x));
32669 }
32670 static void *_p_wxLogTextCtrlTo_p_wxLog(void *x) {
32671 return (void *)((wxLog *) ((wxLogTextCtrl *) x));
32672 }
32673 static void *_p_wxLogWindowTo_p_wxLog(void *x) {
32674 return (void *)((wxLog *) ((wxLogWindow *) x));
32675 }
32676 static void *_p_wxLogChainTo_p_wxLog(void *x) {
32677 return (void *)((wxLog *) ((wxLogChain *) x));
32678 }
32679 static void *_p_wxLogGuiTo_p_wxLog(void *x) {
32680 return (void *)((wxLog *) ((wxLogGui *) x));
32681 }
32682 static void *_p_wxPyLogTo_p_wxLog(void *x) {
32683 return (void *)((wxLog *) ((wxPyLog *) x));
32684 }
32685 static void *_p_wxControlTo_p_wxWindow(void *x) {
32686 return (void *)((wxWindow *) ((wxControl *) x));
32687 }
32688 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
32689 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
32690 }
32691 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
32692 return (void *)((wxWindow *) ((wxMenuBar *) x));
32693 }
32694 static void *_p_wxPyTextDropTargetTo_p_wxPyDropTarget(void *x) {
32695 return (void *)((wxPyDropTarget *) ((wxPyTextDropTarget *) x));
32696 }
32697 static void *_p_wxPyFileDropTargetTo_p_wxPyDropTarget(void *x) {
32698 return (void *)((wxPyDropTarget *) ((wxPyFileDropTarget *) x));
32699 }
32700 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}};
32701 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}};
32702 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}};
32703 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}};
32704 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}};
32705 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}};
32706 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}};
32707 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}};
32708 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}};
32709 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}};
32710 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}};
32711 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}};
32712 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}};
32713 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}};
32714 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}};
32715 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}};
32716 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}};
32717 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}};
32718 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}};
32719 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}};
32720 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}};
32721 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}};
32722 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}};
32723 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}};
32724 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}};
32725 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}};
32726 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}};
32727 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}};
32728 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}};
32729 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}};
32730 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}};
32731 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}};
32732 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}};
32733 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}};
32734 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}};
32735 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}};
32736 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}};
32737 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}};
32738 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}};
32739 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}};
32740 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}};
32741 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}};
32742 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}};
32743 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}};
32744 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}};
32745 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}};
32746 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}};
32747 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}};
32748 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}};
32749 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}};
32750 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}};
32751 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}};
32752 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}};
32753 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}};
32754 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}};
32755 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}};
32756 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}};
32757 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}};
32758 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}};
32759 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}};
32760 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}};
32761 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}};
32762 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}};
32763 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}};
32764 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}};
32765 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}};
32766 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}};
32767 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}};
32768 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}};
32769 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}};
32770 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}};
32771 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}};
32772 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}};
32773 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}};
32774 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}};
32775 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}};
32776 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}};
32777 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}};
32778 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}};
32779 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}};
32780 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}};
32781 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}};
32782 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}};
32783 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}};
32784 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}};
32785 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}};
32786 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}};
32787 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}};
32788 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}};
32789 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}};
32790 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}};
32791 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}};
32792 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}};
32793 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}};
32794 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}};
32795 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}};
32796 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}};
32797
32798 static swig_type_info *swig_types_initial[] = {
32799 _swigt__p_wxLogChain,
32800 _swigt__p_wxMutexGuiLocker,
32801 _swigt__p_wxMetafile,
32802 _swigt__p_wxFileHistory,
32803 _swigt__p_wxLog,
32804 _swigt__p_wxMenu,
32805 _swigt__p_wxEvent,
32806 _swigt__p_wxDateTime__TimeZone,
32807 _swigt__p_wxConfigBase,
32808 _swigt__p_wxDisplay,
32809 _swigt__p_wxFileType,
32810 _swigt__p_wxLogGui,
32811 _swigt__p_wxFont,
32812 _swigt__p_wxDataFormat,
32813 _swigt__p_wxTimerEvent,
32814 _swigt__p_wxCaret,
32815 _swigt__ptrdiff_t,
32816 _swigt__std__ptrdiff_t,
32817 _swigt__p_int,
32818 _swigt__p_wxSize,
32819 _swigt__p_wxClipboard,
32820 _swigt__p_wxStopWatch,
32821 _swigt__p_wxDC,
32822 _swigt__p_wxClipboardLocker,
32823 _swigt__p_wxIcon,
32824 _swigt__p_wxLogStderr,
32825 _swigt__p_wxLogTextCtrl,
32826 _swigt__p_wxTextCtrl,
32827 _swigt__p_wxBusyCursor,
32828 _swigt__p_wxBitmapDataObject,
32829 _swigt__p_wxTextDataObject,
32830 _swigt__p_wxDataObject,
32831 _swigt__p_wxPyTextDataObject,
32832 _swigt__p_wxPyBitmapDataObject,
32833 _swigt__p_wxFileDataObject,
32834 _swigt__p_wxCustomDataObject,
32835 _swigt__p_wxURLDataObject,
32836 _swigt__p_wxMetafileDataObject,
32837 _swigt__p_wxSound,
32838 _swigt__p_wxTimerRunner,
32839 _swigt__p_wxLogWindow,
32840 _swigt__p_wxTimeSpan,
32841 _swigt__p_wxArrayString,
32842 _swigt__p_wxWindowDisabler,
32843 _swigt__p_form_ops_t,
32844 _swigt__p_wxToolTip,
32845 _swigt__p_wxDataObjectComposite,
32846 _swigt__p_wxSystemSettings,
32847 _swigt__p_wxFileConfig,
32848 _swigt__p_wxVideoMode,
32849 _swigt__p_wxDataObjectSimple,
32850 _swigt__p_wxPyDataObjectSimple,
32851 _swigt__p_wxDuplexMode,
32852 _swigt__p_wxEvtHandler,
32853 _swigt__p_wxRect,
32854 _swigt__p_char,
32855 _swigt__p_wxSingleInstanceChecker,
32856 _swigt__p_wxStandardPaths,
32857 _swigt__p_wxFileTypeInfo,
32858 _swigt__p_wxFrame,
32859 _swigt__p_wxTimer,
32860 _swigt__p_wxPaperSize,
32861 _swigt__p_wxMimeTypesManager,
32862 _swigt__p_wxPyArtProvider,
32863 _swigt__p_wxPyTipProvider,
32864 _swigt__p_wxTipProvider,
32865 _swigt__p_wxJoystick,
32866 _swigt__p_wxSystemOptions,
32867 _swigt__p_wxPoint,
32868 _swigt__p_wxJoystickEvent,
32869 _swigt__p_wxCursor,
32870 _swigt__p_wxObject,
32871 _swigt__p_wxOutputStream,
32872 _swigt__p_wxDateTime,
32873 _swigt__p_wxPyDropSource,
32874 _swigt__p_unsigned_long,
32875 _swigt__p_wxKillError,
32876 _swigt__p_wxWindow,
32877 _swigt__p_wxString,
32878 _swigt__p_wxPyProcess,
32879 _swigt__p_wxBitmap,
32880 _swigt__p_wxConfig,
32881 _swigt__unsigned_int,
32882 _swigt__p_unsigned_int,
32883 _swigt__p_unsigned_char,
32884 _swigt__p_wxChar,
32885 _swigt__p_wxBusyInfo,
32886 _swigt__p_wxPyDropTarget,
32887 _swigt__p_wxPyTextDropTarget,
32888 _swigt__p_wxPyFileDropTarget,
32889 _swigt__p_wxProcessEvent,
32890 _swigt__p_wxPyLog,
32891 _swigt__p_wxLogNull,
32892 _swigt__p_wxColour,
32893 _swigt__p_wxPyTimer,
32894 _swigt__p_wxConfigPathChanger,
32895 _swigt__p_wxDateSpan,
32896 0
32897 };
32898
32899
32900 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
32901
32902 static swig_const_info swig_const_table[] = {
32903 { SWIG_PY_POINTER, (char*)"TRACE_MemAlloc", 0, 0, (void *)"memalloc", &SWIGTYPE_p_char},
32904 { SWIG_PY_POINTER, (char*)"TRACE_Messages", 0, 0, (void *)"messages", &SWIGTYPE_p_char},
32905 { SWIG_PY_POINTER, (char*)"TRACE_ResAlloc", 0, 0, (void *)"resalloc", &SWIGTYPE_p_char},
32906 { SWIG_PY_POINTER, (char*)"TRACE_RefCount", 0, 0, (void *)"refcount", &SWIGTYPE_p_char},
32907 { SWIG_PY_POINTER, (char*)"TRACE_OleCalls", 0, 0, (void *)"ole", &SWIGTYPE_p_char},
32908 {0, 0, 0, 0.0, 0, 0}};
32909
32910 #ifdef __cplusplus
32911 }
32912 #endif
32913
32914
32915 #ifdef __cplusplus
32916 extern "C" {
32917 #endif
32918
32919 /* Python-specific SWIG API */
32920 #define SWIG_newvarlink() SWIG_Python_newvarlink()
32921 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
32922 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
32923
32924 /* -----------------------------------------------------------------------------
32925 * global variable support code.
32926 * ----------------------------------------------------------------------------- */
32927
32928 typedef struct swig_globalvar {
32929 char *name; /* Name of global variable */
32930 PyObject *(*get_attr)(); /* Return the current value */
32931 int (*set_attr)(PyObject *); /* Set the value */
32932 struct swig_globalvar *next;
32933 } swig_globalvar;
32934
32935 typedef struct swig_varlinkobject {
32936 PyObject_HEAD
32937 swig_globalvar *vars;
32938 } swig_varlinkobject;
32939
32940 static PyObject *
32941 swig_varlink_repr(swig_varlinkobject *v) {
32942 v = v;
32943 return PyString_FromString("<Swig global variables>");
32944 }
32945
32946 static int
32947 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
32948 swig_globalvar *var;
32949 flags = flags;
32950 fprintf(fp,"Swig global variables { ");
32951 for (var = v->vars; var; var=var->next) {
32952 fprintf(fp,"%s", var->name);
32953 if (var->next) fprintf(fp,", ");
32954 }
32955 fprintf(fp," }\n");
32956 return 0;
32957 }
32958
32959 static PyObject *
32960 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
32961 swig_globalvar *var = v->vars;
32962 while (var) {
32963 if (strcmp(var->name,n) == 0) {
32964 return (*var->get_attr)();
32965 }
32966 var = var->next;
32967 }
32968 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32969 return NULL;
32970 }
32971
32972 static int
32973 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
32974 swig_globalvar *var = v->vars;
32975 while (var) {
32976 if (strcmp(var->name,n) == 0) {
32977 return (*var->set_attr)(p);
32978 }
32979 var = var->next;
32980 }
32981 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
32982 return 1;
32983 }
32984
32985 static PyTypeObject varlinktype = {
32986 PyObject_HEAD_INIT(0)
32987 0, /* Number of items in variable part (ob_size) */
32988 (char *)"swigvarlink", /* Type name (tp_name) */
32989 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
32990 0, /* Itemsize (tp_itemsize) */
32991 0, /* Deallocator (tp_dealloc) */
32992 (printfunc) swig_varlink_print, /* Print (tp_print) */
32993 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
32994 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
32995 0, /* tp_compare */
32996 (reprfunc) swig_varlink_repr, /* tp_repr */
32997 0, /* tp_as_number */
32998 0, /* tp_as_sequence */
32999 0, /* tp_as_mapping */
33000 0, /* tp_hash */
33001 0, /* tp_call */
33002 0, /* tp_str */
33003 0, /* tp_getattro */
33004 0, /* tp_setattro */
33005 0, /* tp_as_buffer */
33006 0, /* tp_flags */
33007 0, /* tp_doc */
33008 #if PY_VERSION_HEX >= 0x02000000
33009 0, /* tp_traverse */
33010 0, /* tp_clear */
33011 #endif
33012 #if PY_VERSION_HEX >= 0x02010000
33013 0, /* tp_richcompare */
33014 0, /* tp_weaklistoffset */
33015 #endif
33016 #if PY_VERSION_HEX >= 0x02020000
33017 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
33018 #endif
33019 #if PY_VERSION_HEX >= 0x02030000
33020 0, /* tp_del */
33021 #endif
33022 #ifdef COUNT_ALLOCS
33023 0,0,0,0 /* tp_alloc -> tp_next */
33024 #endif
33025 };
33026
33027 /* Create a variable linking object for use later */
33028 static PyObject *
33029 SWIG_Python_newvarlink(void) {
33030 swig_varlinkobject *result = 0;
33031 result = PyMem_NEW(swig_varlinkobject,1);
33032 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
33033 result->ob_type = &varlinktype;
33034 result->vars = 0;
33035 result->ob_refcnt = 0;
33036 Py_XINCREF((PyObject *) result);
33037 return ((PyObject*) result);
33038 }
33039
33040 static void
33041 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
33042 swig_varlinkobject *v;
33043 swig_globalvar *gv;
33044 v= (swig_varlinkobject *) p;
33045 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
33046 gv->name = (char *) malloc(strlen(name)+1);
33047 strcpy(gv->name,name);
33048 gv->get_attr = get_attr;
33049 gv->set_attr = set_attr;
33050 gv->next = v->vars;
33051 v->vars = gv;
33052 }
33053
33054 /* -----------------------------------------------------------------------------
33055 * constants/methods manipulation
33056 * ----------------------------------------------------------------------------- */
33057
33058 /* Install Constants */
33059 static void
33060 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
33061 PyObject *obj = 0;
33062 size_t i;
33063 for (i = 0; constants[i].type; i++) {
33064 switch(constants[i].type) {
33065 case SWIG_PY_INT:
33066 obj = PyInt_FromLong(constants[i].lvalue);
33067 break;
33068 case SWIG_PY_FLOAT:
33069 obj = PyFloat_FromDouble(constants[i].dvalue);
33070 break;
33071 case SWIG_PY_STRING:
33072 if (constants[i].pvalue) {
33073 obj = PyString_FromString((char *) constants[i].pvalue);
33074 } else {
33075 Py_INCREF(Py_None);
33076 obj = Py_None;
33077 }
33078 break;
33079 case SWIG_PY_POINTER:
33080 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
33081 break;
33082 case SWIG_PY_BINARY:
33083 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
33084 break;
33085 default:
33086 obj = 0;
33087 break;
33088 }
33089 if (obj) {
33090 PyDict_SetItemString(d,constants[i].name,obj);
33091 Py_DECREF(obj);
33092 }
33093 }
33094 }
33095
33096 /* -----------------------------------------------------------------------------*/
33097 /* Fix SwigMethods to carry the callback ptrs when needed */
33098 /* -----------------------------------------------------------------------------*/
33099
33100 static void
33101 SWIG_Python_FixMethods(PyMethodDef *methods,
33102 swig_const_info *const_table,
33103 swig_type_info **types,
33104 swig_type_info **types_initial) {
33105 size_t i;
33106 for (i = 0; methods[i].ml_name; ++i) {
33107 char *c = methods[i].ml_doc;
33108 if (c && (c = strstr(c, "swig_ptr: "))) {
33109 int j;
33110 swig_const_info *ci = 0;
33111 char *name = c + 10;
33112 for (j = 0; const_table[j].type; j++) {
33113 if (strncmp(const_table[j].name, name,
33114 strlen(const_table[j].name)) == 0) {
33115 ci = &(const_table[j]);
33116 break;
33117 }
33118 }
33119 if (ci) {
33120 size_t shift = (ci->ptype) - types;
33121 swig_type_info *ty = types_initial[shift];
33122 size_t ldoc = (c - methods[i].ml_doc);
33123 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
33124 char *ndoc = (char*)malloc(ldoc + lptr + 10);
33125 char *buff = ndoc;
33126 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
33127 strncpy(buff, methods[i].ml_doc, ldoc);
33128 buff += ldoc;
33129 strncpy(buff, "swig_ptr: ", 10);
33130 buff += 10;
33131 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
33132 methods[i].ml_doc = ndoc;
33133 }
33134 }
33135 }
33136 }
33137
33138 /* -----------------------------------------------------------------------------*
33139 * Initialize type list
33140 * -----------------------------------------------------------------------------*/
33141
33142 #if PY_MAJOR_VERSION < 2
33143 /* PyModule_AddObject function was introduced in Python 2.0. The following function
33144 is copied out of Python/modsupport.c in python version 2.3.4 */
33145 static int
33146 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
33147 {
33148 PyObject *dict;
33149 if (!PyModule_Check(m)) {
33150 PyErr_SetString(PyExc_TypeError,
33151 "PyModule_AddObject() needs module as first arg");
33152 return -1;
33153 }
33154 if (!o) {
33155 PyErr_SetString(PyExc_TypeError,
33156 "PyModule_AddObject() needs non-NULL value");
33157 return -1;
33158 }
33159
33160 dict = PyModule_GetDict(m);
33161 if (dict == NULL) {
33162 /* Internal error -- modules must have a dict! */
33163 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
33164 PyModule_GetName(m));
33165 return -1;
33166 }
33167 if (PyDict_SetItemString(dict, name, o))
33168 return -1;
33169 Py_DECREF(o);
33170 return 0;
33171 }
33172 #endif
33173
33174 static swig_type_info **
33175 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
33176 static PyMethodDef swig_empty_runtime_method_table[] = {
33177 {
33178 NULL, NULL, 0, NULL
33179 }
33180 };/* Sentinel */
33181
33182 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
33183 swig_empty_runtime_method_table);
33184 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
33185 if (pointer && module) {
33186 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
33187 }
33188 return type_list_handle;
33189 }
33190
33191 static swig_type_info **
33192 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
33193 swig_type_info **type_pointer;
33194
33195 /* first check if module already created */
33196 type_pointer = SWIG_Python_GetTypeListHandle();
33197 if (type_pointer) {
33198 return type_pointer;
33199 } else {
33200 /* create a new module and variable */
33201 return SWIG_Python_SetTypeListHandle(type_list_handle);
33202 }
33203 }
33204
33205 #ifdef __cplusplus
33206 }
33207 #endif
33208
33209 /* -----------------------------------------------------------------------------*
33210 * Partial Init method
33211 * -----------------------------------------------------------------------------*/
33212
33213 #ifdef SWIG_LINK_RUNTIME
33214 #ifdef __cplusplus
33215 extern "C"
33216 #endif
33217 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
33218 #endif
33219
33220 #ifdef __cplusplus
33221 extern "C"
33222 #endif
33223 SWIGEXPORT(void) SWIG_init(void) {
33224 static PyObject *SWIG_globals = 0;
33225 static int typeinit = 0;
33226 PyObject *m, *d;
33227 int i;
33228 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
33229
33230 /* Fix SwigMethods to carry the callback ptrs when needed */
33231 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
33232
33233 m = Py_InitModule((char *) SWIG_name, SwigMethods);
33234 d = PyModule_GetDict(m);
33235
33236 if (!typeinit) {
33237 #ifdef SWIG_LINK_RUNTIME
33238 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
33239 #else
33240 # ifndef SWIG_STATIC_RUNTIME
33241 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
33242 # endif
33243 #endif
33244 for (i = 0; swig_types_initial[i]; i++) {
33245 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
33246 }
33247 typeinit = 1;
33248 }
33249 SWIG_InstallConstants(d,swig_const_table);
33250
33251 {
33252 PyDict_SetItemString(d,"SYS_OEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_OEM_FIXED_FONT)));
33253 }
33254 {
33255 PyDict_SetItemString(d,"SYS_ANSI_FIXED_FONT", SWIG_From_int((int)(wxSYS_ANSI_FIXED_FONT)));
33256 }
33257 {
33258 PyDict_SetItemString(d,"SYS_ANSI_VAR_FONT", SWIG_From_int((int)(wxSYS_ANSI_VAR_FONT)));
33259 }
33260 {
33261 PyDict_SetItemString(d,"SYS_SYSTEM_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FONT)));
33262 }
33263 {
33264 PyDict_SetItemString(d,"SYS_DEVICE_DEFAULT_FONT", SWIG_From_int((int)(wxSYS_DEVICE_DEFAULT_FONT)));
33265 }
33266 {
33267 PyDict_SetItemString(d,"SYS_DEFAULT_PALETTE", SWIG_From_int((int)(wxSYS_DEFAULT_PALETTE)));
33268 }
33269 {
33270 PyDict_SetItemString(d,"SYS_SYSTEM_FIXED_FONT", SWIG_From_int((int)(wxSYS_SYSTEM_FIXED_FONT)));
33271 }
33272 {
33273 PyDict_SetItemString(d,"SYS_DEFAULT_GUI_FONT", SWIG_From_int((int)(wxSYS_DEFAULT_GUI_FONT)));
33274 }
33275 {
33276 PyDict_SetItemString(d,"SYS_ICONTITLE_FONT", SWIG_From_int((int)(wxSYS_ICONTITLE_FONT)));
33277 }
33278 {
33279 PyDict_SetItemString(d,"SYS_COLOUR_SCROLLBAR", SWIG_From_int((int)(wxSYS_COLOUR_SCROLLBAR)));
33280 }
33281 {
33282 PyDict_SetItemString(d,"SYS_COLOUR_BACKGROUND", SWIG_From_int((int)(wxSYS_COLOUR_BACKGROUND)));
33283 }
33284 {
33285 PyDict_SetItemString(d,"SYS_COLOUR_DESKTOP", SWIG_From_int((int)(wxSYS_COLOUR_DESKTOP)));
33286 }
33287 {
33288 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVECAPTION)));
33289 }
33290 {
33291 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTION)));
33292 }
33293 {
33294 PyDict_SetItemString(d,"SYS_COLOUR_MENU", SWIG_From_int((int)(wxSYS_COLOUR_MENU)));
33295 }
33296 {
33297 PyDict_SetItemString(d,"SYS_COLOUR_WINDOW", SWIG_From_int((int)(wxSYS_COLOUR_WINDOW)));
33298 }
33299 {
33300 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWFRAME", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWFRAME)));
33301 }
33302 {
33303 PyDict_SetItemString(d,"SYS_COLOUR_MENUTEXT", SWIG_From_int((int)(wxSYS_COLOUR_MENUTEXT)));
33304 }
33305 {
33306 PyDict_SetItemString(d,"SYS_COLOUR_WINDOWTEXT", SWIG_From_int((int)(wxSYS_COLOUR_WINDOWTEXT)));
33307 }
33308 {
33309 PyDict_SetItemString(d,"SYS_COLOUR_CAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_CAPTIONTEXT)));
33310 }
33311 {
33312 PyDict_SetItemString(d,"SYS_COLOUR_ACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_ACTIVEBORDER)));
33313 }
33314 {
33315 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVEBORDER", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVEBORDER)));
33316 }
33317 {
33318 PyDict_SetItemString(d,"SYS_COLOUR_APPWORKSPACE", SWIG_From_int((int)(wxSYS_COLOUR_APPWORKSPACE)));
33319 }
33320 {
33321 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHT)));
33322 }
33323 {
33324 PyDict_SetItemString(d,"SYS_COLOUR_HIGHLIGHTTEXT", SWIG_From_int((int)(wxSYS_COLOUR_HIGHLIGHTTEXT)));
33325 }
33326 {
33327 PyDict_SetItemString(d,"SYS_COLOUR_BTNFACE", SWIG_From_int((int)(wxSYS_COLOUR_BTNFACE)));
33328 }
33329 {
33330 PyDict_SetItemString(d,"SYS_COLOUR_3DFACE", SWIG_From_int((int)(wxSYS_COLOUR_3DFACE)));
33331 }
33332 {
33333 PyDict_SetItemString(d,"SYS_COLOUR_BTNSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_BTNSHADOW)));
33334 }
33335 {
33336 PyDict_SetItemString(d,"SYS_COLOUR_3DSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DSHADOW)));
33337 }
33338 {
33339 PyDict_SetItemString(d,"SYS_COLOUR_GRAYTEXT", SWIG_From_int((int)(wxSYS_COLOUR_GRAYTEXT)));
33340 }
33341 {
33342 PyDict_SetItemString(d,"SYS_COLOUR_BTNTEXT", SWIG_From_int((int)(wxSYS_COLOUR_BTNTEXT)));
33343 }
33344 {
33345 PyDict_SetItemString(d,"SYS_COLOUR_INACTIVECAPTIONTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INACTIVECAPTIONTEXT)));
33346 }
33347 {
33348 PyDict_SetItemString(d,"SYS_COLOUR_BTNHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHIGHLIGHT)));
33349 }
33350 {
33351 PyDict_SetItemString(d,"SYS_COLOUR_BTNHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_BTNHILIGHT)));
33352 }
33353 {
33354 PyDict_SetItemString(d,"SYS_COLOUR_3DHIGHLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHIGHLIGHT)));
33355 }
33356 {
33357 PyDict_SetItemString(d,"SYS_COLOUR_3DHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DHILIGHT)));
33358 }
33359 {
33360 PyDict_SetItemString(d,"SYS_COLOUR_3DDKSHADOW", SWIG_From_int((int)(wxSYS_COLOUR_3DDKSHADOW)));
33361 }
33362 {
33363 PyDict_SetItemString(d,"SYS_COLOUR_3DLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_3DLIGHT)));
33364 }
33365 {
33366 PyDict_SetItemString(d,"SYS_COLOUR_INFOTEXT", SWIG_From_int((int)(wxSYS_COLOUR_INFOTEXT)));
33367 }
33368 {
33369 PyDict_SetItemString(d,"SYS_COLOUR_INFOBK", SWIG_From_int((int)(wxSYS_COLOUR_INFOBK)));
33370 }
33371 {
33372 PyDict_SetItemString(d,"SYS_COLOUR_LISTBOX", SWIG_From_int((int)(wxSYS_COLOUR_LISTBOX)));
33373 }
33374 {
33375 PyDict_SetItemString(d,"SYS_COLOUR_HOTLIGHT", SWIG_From_int((int)(wxSYS_COLOUR_HOTLIGHT)));
33376 }
33377 {
33378 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTACTIVECAPTION)));
33379 }
33380 {
33381 PyDict_SetItemString(d,"SYS_COLOUR_GRADIENTINACTIVECAPTION", SWIG_From_int((int)(wxSYS_COLOUR_GRADIENTINACTIVECAPTION)));
33382 }
33383 {
33384 PyDict_SetItemString(d,"SYS_COLOUR_MENUHILIGHT", SWIG_From_int((int)(wxSYS_COLOUR_MENUHILIGHT)));
33385 }
33386 {
33387 PyDict_SetItemString(d,"SYS_COLOUR_MENUBAR", SWIG_From_int((int)(wxSYS_COLOUR_MENUBAR)));
33388 }
33389 {
33390 PyDict_SetItemString(d,"SYS_COLOUR_MAX", SWIG_From_int((int)(wxSYS_COLOUR_MAX)));
33391 }
33392 {
33393 PyDict_SetItemString(d,"SYS_MOUSE_BUTTONS", SWIG_From_int((int)(wxSYS_MOUSE_BUTTONS)));
33394 }
33395 {
33396 PyDict_SetItemString(d,"SYS_BORDER_X", SWIG_From_int((int)(wxSYS_BORDER_X)));
33397 }
33398 {
33399 PyDict_SetItemString(d,"SYS_BORDER_Y", SWIG_From_int((int)(wxSYS_BORDER_Y)));
33400 }
33401 {
33402 PyDict_SetItemString(d,"SYS_CURSOR_X", SWIG_From_int((int)(wxSYS_CURSOR_X)));
33403 }
33404 {
33405 PyDict_SetItemString(d,"SYS_CURSOR_Y", SWIG_From_int((int)(wxSYS_CURSOR_Y)));
33406 }
33407 {
33408 PyDict_SetItemString(d,"SYS_DCLICK_X", SWIG_From_int((int)(wxSYS_DCLICK_X)));
33409 }
33410 {
33411 PyDict_SetItemString(d,"SYS_DCLICK_Y", SWIG_From_int((int)(wxSYS_DCLICK_Y)));
33412 }
33413 {
33414 PyDict_SetItemString(d,"SYS_DRAG_X", SWIG_From_int((int)(wxSYS_DRAG_X)));
33415 }
33416 {
33417 PyDict_SetItemString(d,"SYS_DRAG_Y", SWIG_From_int((int)(wxSYS_DRAG_Y)));
33418 }
33419 {
33420 PyDict_SetItemString(d,"SYS_EDGE_X", SWIG_From_int((int)(wxSYS_EDGE_X)));
33421 }
33422 {
33423 PyDict_SetItemString(d,"SYS_EDGE_Y", SWIG_From_int((int)(wxSYS_EDGE_Y)));
33424 }
33425 {
33426 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_X)));
33427 }
33428 {
33429 PyDict_SetItemString(d,"SYS_HSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_HSCROLL_ARROW_Y)));
33430 }
33431 {
33432 PyDict_SetItemString(d,"SYS_HTHUMB_X", SWIG_From_int((int)(wxSYS_HTHUMB_X)));
33433 }
33434 {
33435 PyDict_SetItemString(d,"SYS_ICON_X", SWIG_From_int((int)(wxSYS_ICON_X)));
33436 }
33437 {
33438 PyDict_SetItemString(d,"SYS_ICON_Y", SWIG_From_int((int)(wxSYS_ICON_Y)));
33439 }
33440 {
33441 PyDict_SetItemString(d,"SYS_ICONSPACING_X", SWIG_From_int((int)(wxSYS_ICONSPACING_X)));
33442 }
33443 {
33444 PyDict_SetItemString(d,"SYS_ICONSPACING_Y", SWIG_From_int((int)(wxSYS_ICONSPACING_Y)));
33445 }
33446 {
33447 PyDict_SetItemString(d,"SYS_WINDOWMIN_X", SWIG_From_int((int)(wxSYS_WINDOWMIN_X)));
33448 }
33449 {
33450 PyDict_SetItemString(d,"SYS_WINDOWMIN_Y", SWIG_From_int((int)(wxSYS_WINDOWMIN_Y)));
33451 }
33452 {
33453 PyDict_SetItemString(d,"SYS_SCREEN_X", SWIG_From_int((int)(wxSYS_SCREEN_X)));
33454 }
33455 {
33456 PyDict_SetItemString(d,"SYS_SCREEN_Y", SWIG_From_int((int)(wxSYS_SCREEN_Y)));
33457 }
33458 {
33459 PyDict_SetItemString(d,"SYS_FRAMESIZE_X", SWIG_From_int((int)(wxSYS_FRAMESIZE_X)));
33460 }
33461 {
33462 PyDict_SetItemString(d,"SYS_FRAMESIZE_Y", SWIG_From_int((int)(wxSYS_FRAMESIZE_Y)));
33463 }
33464 {
33465 PyDict_SetItemString(d,"SYS_SMALLICON_X", SWIG_From_int((int)(wxSYS_SMALLICON_X)));
33466 }
33467 {
33468 PyDict_SetItemString(d,"SYS_SMALLICON_Y", SWIG_From_int((int)(wxSYS_SMALLICON_Y)));
33469 }
33470 {
33471 PyDict_SetItemString(d,"SYS_HSCROLL_Y", SWIG_From_int((int)(wxSYS_HSCROLL_Y)));
33472 }
33473 {
33474 PyDict_SetItemString(d,"SYS_VSCROLL_X", SWIG_From_int((int)(wxSYS_VSCROLL_X)));
33475 }
33476 {
33477 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_X", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_X)));
33478 }
33479 {
33480 PyDict_SetItemString(d,"SYS_VSCROLL_ARROW_Y", SWIG_From_int((int)(wxSYS_VSCROLL_ARROW_Y)));
33481 }
33482 {
33483 PyDict_SetItemString(d,"SYS_VTHUMB_Y", SWIG_From_int((int)(wxSYS_VTHUMB_Y)));
33484 }
33485 {
33486 PyDict_SetItemString(d,"SYS_CAPTION_Y", SWIG_From_int((int)(wxSYS_CAPTION_Y)));
33487 }
33488 {
33489 PyDict_SetItemString(d,"SYS_MENU_Y", SWIG_From_int((int)(wxSYS_MENU_Y)));
33490 }
33491 {
33492 PyDict_SetItemString(d,"SYS_NETWORK_PRESENT", SWIG_From_int((int)(wxSYS_NETWORK_PRESENT)));
33493 }
33494 {
33495 PyDict_SetItemString(d,"SYS_PENWINDOWS_PRESENT", SWIG_From_int((int)(wxSYS_PENWINDOWS_PRESENT)));
33496 }
33497 {
33498 PyDict_SetItemString(d,"SYS_SHOW_SOUNDS", SWIG_From_int((int)(wxSYS_SHOW_SOUNDS)));
33499 }
33500 {
33501 PyDict_SetItemString(d,"SYS_SWAP_BUTTONS", SWIG_From_int((int)(wxSYS_SWAP_BUTTONS)));
33502 }
33503 {
33504 PyDict_SetItemString(d,"SYS_CAN_DRAW_FRAME_DECORATIONS", SWIG_From_int((int)(wxSYS_CAN_DRAW_FRAME_DECORATIONS)));
33505 }
33506 {
33507 PyDict_SetItemString(d,"SYS_CAN_ICONIZE_FRAME", SWIG_From_int((int)(wxSYS_CAN_ICONIZE_FRAME)));
33508 }
33509 {
33510 PyDict_SetItemString(d,"SYS_SCREEN_NONE", SWIG_From_int((int)(wxSYS_SCREEN_NONE)));
33511 }
33512 {
33513 PyDict_SetItemString(d,"SYS_SCREEN_TINY", SWIG_From_int((int)(wxSYS_SCREEN_TINY)));
33514 }
33515 {
33516 PyDict_SetItemString(d,"SYS_SCREEN_PDA", SWIG_From_int((int)(wxSYS_SCREEN_PDA)));
33517 }
33518 {
33519 PyDict_SetItemString(d,"SYS_SCREEN_SMALL", SWIG_From_int((int)(wxSYS_SCREEN_SMALL)));
33520 }
33521 {
33522 PyDict_SetItemString(d,"SYS_SCREEN_DESKTOP", SWIG_From_int((int)(wxSYS_SCREEN_DESKTOP)));
33523 }
33524 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
33525 SWIG_addvarlink(SWIG_globals,(char*)"WINDOW_DEFAULT_VARIANT",_wrap_WINDOW_DEFAULT_VARIANT_get, _wrap_WINDOW_DEFAULT_VARIANT_set);
33526 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
33527 SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
33528 SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
33529 {
33530 PyDict_SetItemString(d,"SHUTDOWN_POWEROFF", SWIG_From_int((int)(wxSHUTDOWN_POWEROFF)));
33531 }
33532 {
33533 PyDict_SetItemString(d,"SHUTDOWN_REBOOT", SWIG_From_int((int)(wxSHUTDOWN_REBOOT)));
33534 }
33535 {
33536 PyDict_SetItemString(d,"TIMER_CONTINUOUS", SWIG_From_int((int)(wxTIMER_CONTINUOUS)));
33537 }
33538 {
33539 PyDict_SetItemString(d,"TIMER_ONE_SHOT", SWIG_From_int((int)(wxTIMER_ONE_SHOT)));
33540 }
33541 PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
33542
33543 wxPyPtrTypeMap_Add("wxTimer", "wxPyTimer");
33544
33545 {
33546 PyDict_SetItemString(d,"LOG_FatalError", SWIG_From_int((int)(wxLOG_FatalError)));
33547 }
33548 {
33549 PyDict_SetItemString(d,"LOG_Error", SWIG_From_int((int)(wxLOG_Error)));
33550 }
33551 {
33552 PyDict_SetItemString(d,"LOG_Warning", SWIG_From_int((int)(wxLOG_Warning)));
33553 }
33554 {
33555 PyDict_SetItemString(d,"LOG_Message", SWIG_From_int((int)(wxLOG_Message)));
33556 }
33557 {
33558 PyDict_SetItemString(d,"LOG_Status", SWIG_From_int((int)(wxLOG_Status)));
33559 }
33560 {
33561 PyDict_SetItemString(d,"LOG_Info", SWIG_From_int((int)(wxLOG_Info)));
33562 }
33563 {
33564 PyDict_SetItemString(d,"LOG_Debug", SWIG_From_int((int)(wxLOG_Debug)));
33565 }
33566 {
33567 PyDict_SetItemString(d,"LOG_Trace", SWIG_From_int((int)(wxLOG_Trace)));
33568 }
33569 {
33570 PyDict_SetItemString(d,"LOG_Progress", SWIG_From_int((int)(wxLOG_Progress)));
33571 }
33572 {
33573 PyDict_SetItemString(d,"LOG_User", SWIG_From_int((int)(wxLOG_User)));
33574 }
33575 {
33576 PyDict_SetItemString(d,"LOG_Max", SWIG_From_int((int)(wxLOG_Max)));
33577 }
33578 PyDict_SetItemString(d,"TRACE_MemAlloc", SWIG_FromCharPtr("memalloc"));
33579 PyDict_SetItemString(d,"TRACE_Messages", SWIG_FromCharPtr("messages"));
33580 PyDict_SetItemString(d,"TRACE_ResAlloc", SWIG_FromCharPtr("resalloc"));
33581 PyDict_SetItemString(d,"TRACE_RefCount", SWIG_FromCharPtr("refcount"));
33582 PyDict_SetItemString(d,"TRACE_OleCalls", SWIG_FromCharPtr("ole"));
33583 {
33584 PyDict_SetItemString(d,"TraceMemAlloc", SWIG_From_int((int)(0x0001)));
33585 }
33586 {
33587 PyDict_SetItemString(d,"TraceMessages", SWIG_From_int((int)(0x0002)));
33588 }
33589 {
33590 PyDict_SetItemString(d,"TraceResAlloc", SWIG_From_int((int)(0x0004)));
33591 }
33592 {
33593 PyDict_SetItemString(d,"TraceRefCount", SWIG_From_int((int)(0x0008)));
33594 }
33595 {
33596 PyDict_SetItemString(d,"TraceOleCalls", SWIG_From_int((int)(0x0100)));
33597 }
33598 {
33599 PyDict_SetItemString(d,"PROCESS_DEFAULT", SWIG_From_int((int)(wxPROCESS_DEFAULT)));
33600 }
33601 {
33602 PyDict_SetItemString(d,"PROCESS_REDIRECT", SWIG_From_int((int)(wxPROCESS_REDIRECT)));
33603 }
33604 {
33605 PyDict_SetItemString(d,"KILL_OK", SWIG_From_int((int)(wxKILL_OK)));
33606 }
33607 {
33608 PyDict_SetItemString(d,"KILL_BAD_SIGNAL", SWIG_From_int((int)(wxKILL_BAD_SIGNAL)));
33609 }
33610 {
33611 PyDict_SetItemString(d,"KILL_ACCESS_DENIED", SWIG_From_int((int)(wxKILL_ACCESS_DENIED)));
33612 }
33613 {
33614 PyDict_SetItemString(d,"KILL_NO_PROCESS", SWIG_From_int((int)(wxKILL_NO_PROCESS)));
33615 }
33616 {
33617 PyDict_SetItemString(d,"KILL_ERROR", SWIG_From_int((int)(wxKILL_ERROR)));
33618 }
33619 {
33620 PyDict_SetItemString(d,"KILL_NOCHILDREN", SWIG_From_int((int)(wxKILL_NOCHILDREN)));
33621 }
33622 {
33623 PyDict_SetItemString(d,"KILL_CHILDREN", SWIG_From_int((int)(wxKILL_CHILDREN)));
33624 }
33625 {
33626 PyDict_SetItemString(d,"SIGNONE", SWIG_From_int((int)(wxSIGNONE)));
33627 }
33628 {
33629 PyDict_SetItemString(d,"SIGHUP", SWIG_From_int((int)(wxSIGHUP)));
33630 }
33631 {
33632 PyDict_SetItemString(d,"SIGINT", SWIG_From_int((int)(wxSIGINT)));
33633 }
33634 {
33635 PyDict_SetItemString(d,"SIGQUIT", SWIG_From_int((int)(wxSIGQUIT)));
33636 }
33637 {
33638 PyDict_SetItemString(d,"SIGILL", SWIG_From_int((int)(wxSIGILL)));
33639 }
33640 {
33641 PyDict_SetItemString(d,"SIGTRAP", SWIG_From_int((int)(wxSIGTRAP)));
33642 }
33643 {
33644 PyDict_SetItemString(d,"SIGABRT", SWIG_From_int((int)(wxSIGABRT)));
33645 }
33646 {
33647 PyDict_SetItemString(d,"SIGIOT", SWIG_From_int((int)(wxSIGIOT)));
33648 }
33649 {
33650 PyDict_SetItemString(d,"SIGEMT", SWIG_From_int((int)(wxSIGEMT)));
33651 }
33652 {
33653 PyDict_SetItemString(d,"SIGFPE", SWIG_From_int((int)(wxSIGFPE)));
33654 }
33655 {
33656 PyDict_SetItemString(d,"SIGKILL", SWIG_From_int((int)(wxSIGKILL)));
33657 }
33658 {
33659 PyDict_SetItemString(d,"SIGBUS", SWIG_From_int((int)(wxSIGBUS)));
33660 }
33661 {
33662 PyDict_SetItemString(d,"SIGSEGV", SWIG_From_int((int)(wxSIGSEGV)));
33663 }
33664 {
33665 PyDict_SetItemString(d,"SIGSYS", SWIG_From_int((int)(wxSIGSYS)));
33666 }
33667 {
33668 PyDict_SetItemString(d,"SIGPIPE", SWIG_From_int((int)(wxSIGPIPE)));
33669 }
33670 {
33671 PyDict_SetItemString(d,"SIGALRM", SWIG_From_int((int)(wxSIGALRM)));
33672 }
33673 {
33674 PyDict_SetItemString(d,"SIGTERM", SWIG_From_int((int)(wxSIGTERM)));
33675 }
33676 PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
33677 {
33678 PyDict_SetItemString(d,"EXEC_ASYNC", SWIG_From_int((int)(wxEXEC_ASYNC)));
33679 }
33680 {
33681 PyDict_SetItemString(d,"EXEC_SYNC", SWIG_From_int((int)(wxEXEC_SYNC)));
33682 }
33683 {
33684 PyDict_SetItemString(d,"EXEC_NOHIDE", SWIG_From_int((int)(wxEXEC_NOHIDE)));
33685 }
33686 {
33687 PyDict_SetItemString(d,"EXEC_MAKE_GROUP_LEADER", SWIG_From_int((int)(wxEXEC_MAKE_GROUP_LEADER)));
33688 }
33689 {
33690 PyDict_SetItemString(d,"EXEC_NODISABLE", SWIG_From_int((int)(wxEXEC_NODISABLE)));
33691 }
33692
33693 wxPyPtrTypeMap_Add("wxProcess", "wxPyProcess");
33694
33695 {
33696 PyDict_SetItemString(d,"JOYSTICK1", SWIG_From_int((int)(wxJOYSTICK1)));
33697 }
33698 {
33699 PyDict_SetItemString(d,"JOYSTICK2", SWIG_From_int((int)(wxJOYSTICK2)));
33700 }
33701 {
33702 PyDict_SetItemString(d,"JOY_BUTTON_ANY", SWIG_From_int((int)(wxJOY_BUTTON_ANY)));
33703 }
33704 {
33705 PyDict_SetItemString(d,"JOY_BUTTON1", SWIG_From_int((int)(wxJOY_BUTTON1)));
33706 }
33707 {
33708 PyDict_SetItemString(d,"JOY_BUTTON2", SWIG_From_int((int)(wxJOY_BUTTON2)));
33709 }
33710 {
33711 PyDict_SetItemString(d,"JOY_BUTTON3", SWIG_From_int((int)(wxJOY_BUTTON3)));
33712 }
33713 {
33714 PyDict_SetItemString(d,"JOY_BUTTON4", SWIG_From_int((int)(wxJOY_BUTTON4)));
33715 }
33716 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_DOWN", PyInt_FromLong(wxEVT_JOY_BUTTON_DOWN));
33717 PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
33718 PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
33719 PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
33720 {
33721 PyDict_SetItemString(d,"SOUND_SYNC", SWIG_From_int((int)(wxSOUND_SYNC)));
33722 }
33723 {
33724 PyDict_SetItemString(d,"SOUND_ASYNC", SWIG_From_int((int)(wxSOUND_ASYNC)));
33725 }
33726 {
33727 PyDict_SetItemString(d,"SOUND_LOOP", SWIG_From_int((int)(wxSOUND_LOOP)));
33728 }
33729 {
33730 PyDict_SetItemString(d,"MAILCAP_STANDARD", SWIG_From_int((int)(wxMAILCAP_STANDARD)));
33731 }
33732 {
33733 PyDict_SetItemString(d,"MAILCAP_NETSCAPE", SWIG_From_int((int)(wxMAILCAP_NETSCAPE)));
33734 }
33735 {
33736 PyDict_SetItemString(d,"MAILCAP_KDE", SWIG_From_int((int)(wxMAILCAP_KDE)));
33737 }
33738 {
33739 PyDict_SetItemString(d,"MAILCAP_GNOME", SWIG_From_int((int)(wxMAILCAP_GNOME)));
33740 }
33741 {
33742 PyDict_SetItemString(d,"MAILCAP_ALL", SWIG_From_int((int)(wxMAILCAP_ALL)));
33743 }
33744 SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
33745 SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
33746 SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
33747 SWIG_addvarlink(SWIG_globals,(char*)"ART_FRAME_ICON",_wrap_ART_FRAME_ICON_get, _wrap_ART_FRAME_ICON_set);
33748 SWIG_addvarlink(SWIG_globals,(char*)"ART_CMN_DIALOG",_wrap_ART_CMN_DIALOG_get, _wrap_ART_CMN_DIALOG_set);
33749 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BROWSER",_wrap_ART_HELP_BROWSER_get, _wrap_ART_HELP_BROWSER_set);
33750 SWIG_addvarlink(SWIG_globals,(char*)"ART_MESSAGE_BOX",_wrap_ART_MESSAGE_BOX_get, _wrap_ART_MESSAGE_BOX_set);
33751 SWIG_addvarlink(SWIG_globals,(char*)"ART_BUTTON",_wrap_ART_BUTTON_get, _wrap_ART_BUTTON_set);
33752 SWIG_addvarlink(SWIG_globals,(char*)"ART_OTHER",_wrap_ART_OTHER_get, _wrap_ART_OTHER_set);
33753 SWIG_addvarlink(SWIG_globals,(char*)"ART_ADD_BOOKMARK",_wrap_ART_ADD_BOOKMARK_get, _wrap_ART_ADD_BOOKMARK_set);
33754 SWIG_addvarlink(SWIG_globals,(char*)"ART_DEL_BOOKMARK",_wrap_ART_DEL_BOOKMARK_get, _wrap_ART_DEL_BOOKMARK_set);
33755 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SIDE_PANEL",_wrap_ART_HELP_SIDE_PANEL_get, _wrap_ART_HELP_SIDE_PANEL_set);
33756 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_SETTINGS",_wrap_ART_HELP_SETTINGS_get, _wrap_ART_HELP_SETTINGS_set);
33757 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_BOOK",_wrap_ART_HELP_BOOK_get, _wrap_ART_HELP_BOOK_set);
33758 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_FOLDER",_wrap_ART_HELP_FOLDER_get, _wrap_ART_HELP_FOLDER_set);
33759 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP_PAGE",_wrap_ART_HELP_PAGE_get, _wrap_ART_HELP_PAGE_set);
33760 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_BACK",_wrap_ART_GO_BACK_get, _wrap_ART_GO_BACK_set);
33761 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_FORWARD",_wrap_ART_GO_FORWARD_get, _wrap_ART_GO_FORWARD_set);
33762 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_UP",_wrap_ART_GO_UP_get, _wrap_ART_GO_UP_set);
33763 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DOWN",_wrap_ART_GO_DOWN_get, _wrap_ART_GO_DOWN_set);
33764 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_TO_PARENT",_wrap_ART_GO_TO_PARENT_get, _wrap_ART_GO_TO_PARENT_set);
33765 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_HOME",_wrap_ART_GO_HOME_get, _wrap_ART_GO_HOME_set);
33766 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_OPEN",_wrap_ART_FILE_OPEN_get, _wrap_ART_FILE_OPEN_set);
33767 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE",_wrap_ART_FILE_SAVE_get, _wrap_ART_FILE_SAVE_set);
33768 SWIG_addvarlink(SWIG_globals,(char*)"ART_FILE_SAVE_AS",_wrap_ART_FILE_SAVE_AS_get, _wrap_ART_FILE_SAVE_AS_set);
33769 SWIG_addvarlink(SWIG_globals,(char*)"ART_PRINT",_wrap_ART_PRINT_get, _wrap_ART_PRINT_set);
33770 SWIG_addvarlink(SWIG_globals,(char*)"ART_HELP",_wrap_ART_HELP_get, _wrap_ART_HELP_set);
33771 SWIG_addvarlink(SWIG_globals,(char*)"ART_TIP",_wrap_ART_TIP_get, _wrap_ART_TIP_set);
33772 SWIG_addvarlink(SWIG_globals,(char*)"ART_REPORT_VIEW",_wrap_ART_REPORT_VIEW_get, _wrap_ART_REPORT_VIEW_set);
33773 SWIG_addvarlink(SWIG_globals,(char*)"ART_LIST_VIEW",_wrap_ART_LIST_VIEW_get, _wrap_ART_LIST_VIEW_set);
33774 SWIG_addvarlink(SWIG_globals,(char*)"ART_NEW_DIR",_wrap_ART_NEW_DIR_get, _wrap_ART_NEW_DIR_set);
33775 SWIG_addvarlink(SWIG_globals,(char*)"ART_HARDDISK",_wrap_ART_HARDDISK_get, _wrap_ART_HARDDISK_set);
33776 SWIG_addvarlink(SWIG_globals,(char*)"ART_FLOPPY",_wrap_ART_FLOPPY_get, _wrap_ART_FLOPPY_set);
33777 SWIG_addvarlink(SWIG_globals,(char*)"ART_CDROM",_wrap_ART_CDROM_get, _wrap_ART_CDROM_set);
33778 SWIG_addvarlink(SWIG_globals,(char*)"ART_REMOVABLE",_wrap_ART_REMOVABLE_get, _wrap_ART_REMOVABLE_set);
33779 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER",_wrap_ART_FOLDER_get, _wrap_ART_FOLDER_set);
33780 SWIG_addvarlink(SWIG_globals,(char*)"ART_FOLDER_OPEN",_wrap_ART_FOLDER_OPEN_get, _wrap_ART_FOLDER_OPEN_set);
33781 SWIG_addvarlink(SWIG_globals,(char*)"ART_GO_DIR_UP",_wrap_ART_GO_DIR_UP_get, _wrap_ART_GO_DIR_UP_set);
33782 SWIG_addvarlink(SWIG_globals,(char*)"ART_EXECUTABLE_FILE",_wrap_ART_EXECUTABLE_FILE_get, _wrap_ART_EXECUTABLE_FILE_set);
33783 SWIG_addvarlink(SWIG_globals,(char*)"ART_NORMAL_FILE",_wrap_ART_NORMAL_FILE_get, _wrap_ART_NORMAL_FILE_set);
33784 SWIG_addvarlink(SWIG_globals,(char*)"ART_TICK_MARK",_wrap_ART_TICK_MARK_get, _wrap_ART_TICK_MARK_set);
33785 SWIG_addvarlink(SWIG_globals,(char*)"ART_CROSS_MARK",_wrap_ART_CROSS_MARK_get, _wrap_ART_CROSS_MARK_set);
33786 SWIG_addvarlink(SWIG_globals,(char*)"ART_ERROR",_wrap_ART_ERROR_get, _wrap_ART_ERROR_set);
33787 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUESTION",_wrap_ART_QUESTION_get, _wrap_ART_QUESTION_set);
33788 SWIG_addvarlink(SWIG_globals,(char*)"ART_WARNING",_wrap_ART_WARNING_get, _wrap_ART_WARNING_set);
33789 SWIG_addvarlink(SWIG_globals,(char*)"ART_INFORMATION",_wrap_ART_INFORMATION_get, _wrap_ART_INFORMATION_set);
33790 SWIG_addvarlink(SWIG_globals,(char*)"ART_MISSING_IMAGE",_wrap_ART_MISSING_IMAGE_get, _wrap_ART_MISSING_IMAGE_set);
33791 SWIG_addvarlink(SWIG_globals,(char*)"ART_COPY",_wrap_ART_COPY_get, _wrap_ART_COPY_set);
33792 SWIG_addvarlink(SWIG_globals,(char*)"ART_CUT",_wrap_ART_CUT_get, _wrap_ART_CUT_set);
33793 SWIG_addvarlink(SWIG_globals,(char*)"ART_PASTE",_wrap_ART_PASTE_get, _wrap_ART_PASTE_set);
33794 SWIG_addvarlink(SWIG_globals,(char*)"ART_DELETE",_wrap_ART_DELETE_get, _wrap_ART_DELETE_set);
33795 SWIG_addvarlink(SWIG_globals,(char*)"ART_UNDO",_wrap_ART_UNDO_get, _wrap_ART_UNDO_set);
33796 SWIG_addvarlink(SWIG_globals,(char*)"ART_REDO",_wrap_ART_REDO_get, _wrap_ART_REDO_set);
33797 SWIG_addvarlink(SWIG_globals,(char*)"ART_QUIT",_wrap_ART_QUIT_get, _wrap_ART_QUIT_set);
33798 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND",_wrap_ART_FIND_get, _wrap_ART_FIND_set);
33799 SWIG_addvarlink(SWIG_globals,(char*)"ART_FIND_AND_REPLACE",_wrap_ART_FIND_AND_REPLACE_get, _wrap_ART_FIND_AND_REPLACE_set);
33800
33801 wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
33802
33803 {
33804 PyDict_SetItemString(d,"CONFIG_USE_LOCAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_LOCAL_FILE)));
33805 }
33806 {
33807 PyDict_SetItemString(d,"CONFIG_USE_GLOBAL_FILE", SWIG_From_int((int)(wxCONFIG_USE_GLOBAL_FILE)));
33808 }
33809 {
33810 PyDict_SetItemString(d,"CONFIG_USE_RELATIVE_PATH", SWIG_From_int((int)(wxCONFIG_USE_RELATIVE_PATH)));
33811 }
33812 {
33813 PyDict_SetItemString(d,"CONFIG_USE_NO_ESCAPE_CHARACTERS", SWIG_From_int((int)(wxCONFIG_USE_NO_ESCAPE_CHARACTERS)));
33814 }
33815 {
33816 PyDict_SetItemString(d,"ConfigBase_Type_Unknown", SWIG_From_int((int)(wxConfigBase::Type_Unknown)));
33817 }
33818 {
33819 PyDict_SetItemString(d,"ConfigBase_Type_String", SWIG_From_int((int)(wxConfigBase::Type_String)));
33820 }
33821 {
33822 PyDict_SetItemString(d,"ConfigBase_Type_Boolean", SWIG_From_int((int)(wxConfigBase::Type_Boolean)));
33823 }
33824 {
33825 PyDict_SetItemString(d,"ConfigBase_Type_Integer", SWIG_From_int((int)(wxConfigBase::Type_Integer)));
33826 }
33827 {
33828 PyDict_SetItemString(d,"ConfigBase_Type_Float", SWIG_From_int((int)(wxConfigBase::Type_Float)));
33829 }
33830 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTimeFormat",_wrap_DefaultDateTimeFormat_get, _wrap_DefaultDateTimeFormat_set);
33831 SWIG_addvarlink(SWIG_globals,(char*)"DefaultTimeSpanFormat",_wrap_DefaultTimeSpanFormat_get, _wrap_DefaultTimeSpanFormat_set);
33832 {
33833 PyDict_SetItemString(d,"DateTime_Local", SWIG_From_int((int)(wxDateTime::Local)));
33834 }
33835 {
33836 PyDict_SetItemString(d,"DateTime_GMT_12", SWIG_From_int((int)(wxDateTime::GMT_12)));
33837 }
33838 {
33839 PyDict_SetItemString(d,"DateTime_GMT_11", SWIG_From_int((int)(wxDateTime::GMT_11)));
33840 }
33841 {
33842 PyDict_SetItemString(d,"DateTime_GMT_10", SWIG_From_int((int)(wxDateTime::GMT_10)));
33843 }
33844 {
33845 PyDict_SetItemString(d,"DateTime_GMT_9", SWIG_From_int((int)(wxDateTime::GMT_9)));
33846 }
33847 {
33848 PyDict_SetItemString(d,"DateTime_GMT_8", SWIG_From_int((int)(wxDateTime::GMT_8)));
33849 }
33850 {
33851 PyDict_SetItemString(d,"DateTime_GMT_7", SWIG_From_int((int)(wxDateTime::GMT_7)));
33852 }
33853 {
33854 PyDict_SetItemString(d,"DateTime_GMT_6", SWIG_From_int((int)(wxDateTime::GMT_6)));
33855 }
33856 {
33857 PyDict_SetItemString(d,"DateTime_GMT_5", SWIG_From_int((int)(wxDateTime::GMT_5)));
33858 }
33859 {
33860 PyDict_SetItemString(d,"DateTime_GMT_4", SWIG_From_int((int)(wxDateTime::GMT_4)));
33861 }
33862 {
33863 PyDict_SetItemString(d,"DateTime_GMT_3", SWIG_From_int((int)(wxDateTime::GMT_3)));
33864 }
33865 {
33866 PyDict_SetItemString(d,"DateTime_GMT_2", SWIG_From_int((int)(wxDateTime::GMT_2)));
33867 }
33868 {
33869 PyDict_SetItemString(d,"DateTime_GMT_1", SWIG_From_int((int)(wxDateTime::GMT_1)));
33870 }
33871 {
33872 PyDict_SetItemString(d,"DateTime_GMT0", SWIG_From_int((int)(wxDateTime::GMT0)));
33873 }
33874 {
33875 PyDict_SetItemString(d,"DateTime_GMT1", SWIG_From_int((int)(wxDateTime::GMT1)));
33876 }
33877 {
33878 PyDict_SetItemString(d,"DateTime_GMT2", SWIG_From_int((int)(wxDateTime::GMT2)));
33879 }
33880 {
33881 PyDict_SetItemString(d,"DateTime_GMT3", SWIG_From_int((int)(wxDateTime::GMT3)));
33882 }
33883 {
33884 PyDict_SetItemString(d,"DateTime_GMT4", SWIG_From_int((int)(wxDateTime::GMT4)));
33885 }
33886 {
33887 PyDict_SetItemString(d,"DateTime_GMT5", SWIG_From_int((int)(wxDateTime::GMT5)));
33888 }
33889 {
33890 PyDict_SetItemString(d,"DateTime_GMT6", SWIG_From_int((int)(wxDateTime::GMT6)));
33891 }
33892 {
33893 PyDict_SetItemString(d,"DateTime_GMT7", SWIG_From_int((int)(wxDateTime::GMT7)));
33894 }
33895 {
33896 PyDict_SetItemString(d,"DateTime_GMT8", SWIG_From_int((int)(wxDateTime::GMT8)));
33897 }
33898 {
33899 PyDict_SetItemString(d,"DateTime_GMT9", SWIG_From_int((int)(wxDateTime::GMT9)));
33900 }
33901 {
33902 PyDict_SetItemString(d,"DateTime_GMT10", SWIG_From_int((int)(wxDateTime::GMT10)));
33903 }
33904 {
33905 PyDict_SetItemString(d,"DateTime_GMT11", SWIG_From_int((int)(wxDateTime::GMT11)));
33906 }
33907 {
33908 PyDict_SetItemString(d,"DateTime_GMT12", SWIG_From_int((int)(wxDateTime::GMT12)));
33909 }
33910 {
33911 PyDict_SetItemString(d,"DateTime_WET", SWIG_From_int((int)(wxDateTime::WET)));
33912 }
33913 {
33914 PyDict_SetItemString(d,"DateTime_WEST", SWIG_From_int((int)(wxDateTime::WEST)));
33915 }
33916 {
33917 PyDict_SetItemString(d,"DateTime_CET", SWIG_From_int((int)(wxDateTime::CET)));
33918 }
33919 {
33920 PyDict_SetItemString(d,"DateTime_CEST", SWIG_From_int((int)(wxDateTime::CEST)));
33921 }
33922 {
33923 PyDict_SetItemString(d,"DateTime_EET", SWIG_From_int((int)(wxDateTime::EET)));
33924 }
33925 {
33926 PyDict_SetItemString(d,"DateTime_EEST", SWIG_From_int((int)(wxDateTime::EEST)));
33927 }
33928 {
33929 PyDict_SetItemString(d,"DateTime_MSK", SWIG_From_int((int)(wxDateTime::MSK)));
33930 }
33931 {
33932 PyDict_SetItemString(d,"DateTime_MSD", SWIG_From_int((int)(wxDateTime::MSD)));
33933 }
33934 {
33935 PyDict_SetItemString(d,"DateTime_AST", SWIG_From_int((int)(wxDateTime::AST)));
33936 }
33937 {
33938 PyDict_SetItemString(d,"DateTime_ADT", SWIG_From_int((int)(wxDateTime::ADT)));
33939 }
33940 {
33941 PyDict_SetItemString(d,"DateTime_EST", SWIG_From_int((int)(wxDateTime::EST)));
33942 }
33943 {
33944 PyDict_SetItemString(d,"DateTime_EDT", SWIG_From_int((int)(wxDateTime::EDT)));
33945 }
33946 {
33947 PyDict_SetItemString(d,"DateTime_CST", SWIG_From_int((int)(wxDateTime::CST)));
33948 }
33949 {
33950 PyDict_SetItemString(d,"DateTime_CDT", SWIG_From_int((int)(wxDateTime::CDT)));
33951 }
33952 {
33953 PyDict_SetItemString(d,"DateTime_MST", SWIG_From_int((int)(wxDateTime::MST)));
33954 }
33955 {
33956 PyDict_SetItemString(d,"DateTime_MDT", SWIG_From_int((int)(wxDateTime::MDT)));
33957 }
33958 {
33959 PyDict_SetItemString(d,"DateTime_PST", SWIG_From_int((int)(wxDateTime::PST)));
33960 }
33961 {
33962 PyDict_SetItemString(d,"DateTime_PDT", SWIG_From_int((int)(wxDateTime::PDT)));
33963 }
33964 {
33965 PyDict_SetItemString(d,"DateTime_HST", SWIG_From_int((int)(wxDateTime::HST)));
33966 }
33967 {
33968 PyDict_SetItemString(d,"DateTime_AKST", SWIG_From_int((int)(wxDateTime::AKST)));
33969 }
33970 {
33971 PyDict_SetItemString(d,"DateTime_AKDT", SWIG_From_int((int)(wxDateTime::AKDT)));
33972 }
33973 {
33974 PyDict_SetItemString(d,"DateTime_A_WST", SWIG_From_int((int)(wxDateTime::A_WST)));
33975 }
33976 {
33977 PyDict_SetItemString(d,"DateTime_A_CST", SWIG_From_int((int)(wxDateTime::A_CST)));
33978 }
33979 {
33980 PyDict_SetItemString(d,"DateTime_A_EST", SWIG_From_int((int)(wxDateTime::A_EST)));
33981 }
33982 {
33983 PyDict_SetItemString(d,"DateTime_A_ESST", SWIG_From_int((int)(wxDateTime::A_ESST)));
33984 }
33985 {
33986 PyDict_SetItemString(d,"DateTime_UTC", SWIG_From_int((int)(wxDateTime::UTC)));
33987 }
33988 {
33989 PyDict_SetItemString(d,"DateTime_Gregorian", SWIG_From_int((int)(wxDateTime::Gregorian)));
33990 }
33991 {
33992 PyDict_SetItemString(d,"DateTime_Julian", SWIG_From_int((int)(wxDateTime::Julian)));
33993 }
33994 {
33995 PyDict_SetItemString(d,"DateTime_Gr_Unknown", SWIG_From_int((int)(wxDateTime::Gr_Unknown)));
33996 }
33997 {
33998 PyDict_SetItemString(d,"DateTime_Gr_Standard", SWIG_From_int((int)(wxDateTime::Gr_Standard)));
33999 }
34000 {
34001 PyDict_SetItemString(d,"DateTime_Gr_Alaska", SWIG_From_int((int)(wxDateTime::Gr_Alaska)));
34002 }
34003 {
34004 PyDict_SetItemString(d,"DateTime_Gr_Albania", SWIG_From_int((int)(wxDateTime::Gr_Albania)));
34005 }
34006 {
34007 PyDict_SetItemString(d,"DateTime_Gr_Austria", SWIG_From_int((int)(wxDateTime::Gr_Austria)));
34008 }
34009 {
34010 PyDict_SetItemString(d,"DateTime_Gr_Austria_Brixen", SWIG_From_int((int)(wxDateTime::Gr_Austria_Brixen)));
34011 }
34012 {
34013 PyDict_SetItemString(d,"DateTime_Gr_Austria_Salzburg", SWIG_From_int((int)(wxDateTime::Gr_Austria_Salzburg)));
34014 }
34015 {
34016 PyDict_SetItemString(d,"DateTime_Gr_Austria_Tyrol", SWIG_From_int((int)(wxDateTime::Gr_Austria_Tyrol)));
34017 }
34018 {
34019 PyDict_SetItemString(d,"DateTime_Gr_Austria_Carinthia", SWIG_From_int((int)(wxDateTime::Gr_Austria_Carinthia)));
34020 }
34021 {
34022 PyDict_SetItemString(d,"DateTime_Gr_Austria_Styria", SWIG_From_int((int)(wxDateTime::Gr_Austria_Styria)));
34023 }
34024 {
34025 PyDict_SetItemString(d,"DateTime_Gr_Belgium", SWIG_From_int((int)(wxDateTime::Gr_Belgium)));
34026 }
34027 {
34028 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria)));
34029 }
34030 {
34031 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_1", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_1)));
34032 }
34033 {
34034 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_2", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_2)));
34035 }
34036 {
34037 PyDict_SetItemString(d,"DateTime_Gr_Bulgaria_3", SWIG_From_int((int)(wxDateTime::Gr_Bulgaria_3)));
34038 }
34039 {
34040 PyDict_SetItemString(d,"DateTime_Gr_Canada", SWIG_From_int((int)(wxDateTime::Gr_Canada)));
34041 }
34042 {
34043 PyDict_SetItemString(d,"DateTime_Gr_China", SWIG_From_int((int)(wxDateTime::Gr_China)));
34044 }
34045 {
34046 PyDict_SetItemString(d,"DateTime_Gr_China_1", SWIG_From_int((int)(wxDateTime::Gr_China_1)));
34047 }
34048 {
34049 PyDict_SetItemString(d,"DateTime_Gr_China_2", SWIG_From_int((int)(wxDateTime::Gr_China_2)));
34050 }
34051 {
34052 PyDict_SetItemString(d,"DateTime_Gr_Czechoslovakia", SWIG_From_int((int)(wxDateTime::Gr_Czechoslovakia)));
34053 }
34054 {
34055 PyDict_SetItemString(d,"DateTime_Gr_Denmark", SWIG_From_int((int)(wxDateTime::Gr_Denmark)));
34056 }
34057 {
34058 PyDict_SetItemString(d,"DateTime_Gr_Egypt", SWIG_From_int((int)(wxDateTime::Gr_Egypt)));
34059 }
34060 {
34061 PyDict_SetItemString(d,"DateTime_Gr_Estonia", SWIG_From_int((int)(wxDateTime::Gr_Estonia)));
34062 }
34063 {
34064 PyDict_SetItemString(d,"DateTime_Gr_Finland", SWIG_From_int((int)(wxDateTime::Gr_Finland)));
34065 }
34066 {
34067 PyDict_SetItemString(d,"DateTime_Gr_France", SWIG_From_int((int)(wxDateTime::Gr_France)));
34068 }
34069 {
34070 PyDict_SetItemString(d,"DateTime_Gr_France_Alsace", SWIG_From_int((int)(wxDateTime::Gr_France_Alsace)));
34071 }
34072 {
34073 PyDict_SetItemString(d,"DateTime_Gr_France_Lorraine", SWIG_From_int((int)(wxDateTime::Gr_France_Lorraine)));
34074 }
34075 {
34076 PyDict_SetItemString(d,"DateTime_Gr_France_Strasbourg", SWIG_From_int((int)(wxDateTime::Gr_France_Strasbourg)));
34077 }
34078 {
34079 PyDict_SetItemString(d,"DateTime_Gr_Germany", SWIG_From_int((int)(wxDateTime::Gr_Germany)));
34080 }
34081 {
34082 PyDict_SetItemString(d,"DateTime_Gr_Germany_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Germany_Catholic)));
34083 }
34084 {
34085 PyDict_SetItemString(d,"DateTime_Gr_Germany_Prussia", SWIG_From_int((int)(wxDateTime::Gr_Germany_Prussia)));
34086 }
34087 {
34088 PyDict_SetItemString(d,"DateTime_Gr_Germany_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Germany_Protestant)));
34089 }
34090 {
34091 PyDict_SetItemString(d,"DateTime_Gr_GreatBritain", SWIG_From_int((int)(wxDateTime::Gr_GreatBritain)));
34092 }
34093 {
34094 PyDict_SetItemString(d,"DateTime_Gr_Greece", SWIG_From_int((int)(wxDateTime::Gr_Greece)));
34095 }
34096 {
34097 PyDict_SetItemString(d,"DateTime_Gr_Hungary", SWIG_From_int((int)(wxDateTime::Gr_Hungary)));
34098 }
34099 {
34100 PyDict_SetItemString(d,"DateTime_Gr_Ireland", SWIG_From_int((int)(wxDateTime::Gr_Ireland)));
34101 }
34102 {
34103 PyDict_SetItemString(d,"DateTime_Gr_Italy", SWIG_From_int((int)(wxDateTime::Gr_Italy)));
34104 }
34105 {
34106 PyDict_SetItemString(d,"DateTime_Gr_Japan", SWIG_From_int((int)(wxDateTime::Gr_Japan)));
34107 }
34108 {
34109 PyDict_SetItemString(d,"DateTime_Gr_Japan_1", SWIG_From_int((int)(wxDateTime::Gr_Japan_1)));
34110 }
34111 {
34112 PyDict_SetItemString(d,"DateTime_Gr_Japan_2", SWIG_From_int((int)(wxDateTime::Gr_Japan_2)));
34113 }
34114 {
34115 PyDict_SetItemString(d,"DateTime_Gr_Japan_3", SWIG_From_int((int)(wxDateTime::Gr_Japan_3)));
34116 }
34117 {
34118 PyDict_SetItemString(d,"DateTime_Gr_Latvia", SWIG_From_int((int)(wxDateTime::Gr_Latvia)));
34119 }
34120 {
34121 PyDict_SetItemString(d,"DateTime_Gr_Lithuania", SWIG_From_int((int)(wxDateTime::Gr_Lithuania)));
34122 }
34123 {
34124 PyDict_SetItemString(d,"DateTime_Gr_Luxemburg", SWIG_From_int((int)(wxDateTime::Gr_Luxemburg)));
34125 }
34126 {
34127 PyDict_SetItemString(d,"DateTime_Gr_Netherlands", SWIG_From_int((int)(wxDateTime::Gr_Netherlands)));
34128 }
34129 {
34130 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Groningen", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Groningen)));
34131 }
34132 {
34133 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Gelderland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Gelderland)));
34134 }
34135 {
34136 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Utrecht", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Utrecht)));
34137 }
34138 {
34139 PyDict_SetItemString(d,"DateTime_Gr_Netherlands_Friesland", SWIG_From_int((int)(wxDateTime::Gr_Netherlands_Friesland)));
34140 }
34141 {
34142 PyDict_SetItemString(d,"DateTime_Gr_Norway", SWIG_From_int((int)(wxDateTime::Gr_Norway)));
34143 }
34144 {
34145 PyDict_SetItemString(d,"DateTime_Gr_Poland", SWIG_From_int((int)(wxDateTime::Gr_Poland)));
34146 }
34147 {
34148 PyDict_SetItemString(d,"DateTime_Gr_Portugal", SWIG_From_int((int)(wxDateTime::Gr_Portugal)));
34149 }
34150 {
34151 PyDict_SetItemString(d,"DateTime_Gr_Romania", SWIG_From_int((int)(wxDateTime::Gr_Romania)));
34152 }
34153 {
34154 PyDict_SetItemString(d,"DateTime_Gr_Russia", SWIG_From_int((int)(wxDateTime::Gr_Russia)));
34155 }
34156 {
34157 PyDict_SetItemString(d,"DateTime_Gr_Scotland", SWIG_From_int((int)(wxDateTime::Gr_Scotland)));
34158 }
34159 {
34160 PyDict_SetItemString(d,"DateTime_Gr_Spain", SWIG_From_int((int)(wxDateTime::Gr_Spain)));
34161 }
34162 {
34163 PyDict_SetItemString(d,"DateTime_Gr_Sweden", SWIG_From_int((int)(wxDateTime::Gr_Sweden)));
34164 }
34165 {
34166 PyDict_SetItemString(d,"DateTime_Gr_Switzerland", SWIG_From_int((int)(wxDateTime::Gr_Switzerland)));
34167 }
34168 {
34169 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Catholic", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Catholic)));
34170 }
34171 {
34172 PyDict_SetItemString(d,"DateTime_Gr_Switzerland_Protestant", SWIG_From_int((int)(wxDateTime::Gr_Switzerland_Protestant)));
34173 }
34174 {
34175 PyDict_SetItemString(d,"DateTime_Gr_Turkey", SWIG_From_int((int)(wxDateTime::Gr_Turkey)));
34176 }
34177 {
34178 PyDict_SetItemString(d,"DateTime_Gr_USA", SWIG_From_int((int)(wxDateTime::Gr_USA)));
34179 }
34180 {
34181 PyDict_SetItemString(d,"DateTime_Gr_Wales", SWIG_From_int((int)(wxDateTime::Gr_Wales)));
34182 }
34183 {
34184 PyDict_SetItemString(d,"DateTime_Gr_Yugoslavia", SWIG_From_int((int)(wxDateTime::Gr_Yugoslavia)));
34185 }
34186 {
34187 PyDict_SetItemString(d,"DateTime_Country_Unknown", SWIG_From_int((int)(wxDateTime::Country_Unknown)));
34188 }
34189 {
34190 PyDict_SetItemString(d,"DateTime_Country_Default", SWIG_From_int((int)(wxDateTime::Country_Default)));
34191 }
34192 {
34193 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_Start", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_Start)));
34194 }
34195 {
34196 PyDict_SetItemString(d,"DateTime_Country_EEC", SWIG_From_int((int)(wxDateTime::Country_EEC)));
34197 }
34198 {
34199 PyDict_SetItemString(d,"DateTime_France", SWIG_From_int((int)(wxDateTime::France)));
34200 }
34201 {
34202 PyDict_SetItemString(d,"DateTime_Germany", SWIG_From_int((int)(wxDateTime::Germany)));
34203 }
34204 {
34205 PyDict_SetItemString(d,"DateTime_UK", SWIG_From_int((int)(wxDateTime::UK)));
34206 }
34207 {
34208 PyDict_SetItemString(d,"DateTime_Country_WesternEurope_End", SWIG_From_int((int)(wxDateTime::Country_WesternEurope_End)));
34209 }
34210 {
34211 PyDict_SetItemString(d,"DateTime_Russia", SWIG_From_int((int)(wxDateTime::Russia)));
34212 }
34213 {
34214 PyDict_SetItemString(d,"DateTime_USA", SWIG_From_int((int)(wxDateTime::USA)));
34215 }
34216 {
34217 PyDict_SetItemString(d,"DateTime_Jan", SWIG_From_int((int)(wxDateTime::Jan)));
34218 }
34219 {
34220 PyDict_SetItemString(d,"DateTime_Feb", SWIG_From_int((int)(wxDateTime::Feb)));
34221 }
34222 {
34223 PyDict_SetItemString(d,"DateTime_Mar", SWIG_From_int((int)(wxDateTime::Mar)));
34224 }
34225 {
34226 PyDict_SetItemString(d,"DateTime_Apr", SWIG_From_int((int)(wxDateTime::Apr)));
34227 }
34228 {
34229 PyDict_SetItemString(d,"DateTime_May", SWIG_From_int((int)(wxDateTime::May)));
34230 }
34231 {
34232 PyDict_SetItemString(d,"DateTime_Jun", SWIG_From_int((int)(wxDateTime::Jun)));
34233 }
34234 {
34235 PyDict_SetItemString(d,"DateTime_Jul", SWIG_From_int((int)(wxDateTime::Jul)));
34236 }
34237 {
34238 PyDict_SetItemString(d,"DateTime_Aug", SWIG_From_int((int)(wxDateTime::Aug)));
34239 }
34240 {
34241 PyDict_SetItemString(d,"DateTime_Sep", SWIG_From_int((int)(wxDateTime::Sep)));
34242 }
34243 {
34244 PyDict_SetItemString(d,"DateTime_Oct", SWIG_From_int((int)(wxDateTime::Oct)));
34245 }
34246 {
34247 PyDict_SetItemString(d,"DateTime_Nov", SWIG_From_int((int)(wxDateTime::Nov)));
34248 }
34249 {
34250 PyDict_SetItemString(d,"DateTime_Dec", SWIG_From_int((int)(wxDateTime::Dec)));
34251 }
34252 {
34253 PyDict_SetItemString(d,"DateTime_Inv_Month", SWIG_From_int((int)(wxDateTime::Inv_Month)));
34254 }
34255 {
34256 PyDict_SetItemString(d,"DateTime_Sun", SWIG_From_int((int)(wxDateTime::Sun)));
34257 }
34258 {
34259 PyDict_SetItemString(d,"DateTime_Mon", SWIG_From_int((int)(wxDateTime::Mon)));
34260 }
34261 {
34262 PyDict_SetItemString(d,"DateTime_Tue", SWIG_From_int((int)(wxDateTime::Tue)));
34263 }
34264 {
34265 PyDict_SetItemString(d,"DateTime_Wed", SWIG_From_int((int)(wxDateTime::Wed)));
34266 }
34267 {
34268 PyDict_SetItemString(d,"DateTime_Thu", SWIG_From_int((int)(wxDateTime::Thu)));
34269 }
34270 {
34271 PyDict_SetItemString(d,"DateTime_Fri", SWIG_From_int((int)(wxDateTime::Fri)));
34272 }
34273 {
34274 PyDict_SetItemString(d,"DateTime_Sat", SWIG_From_int((int)(wxDateTime::Sat)));
34275 }
34276 {
34277 PyDict_SetItemString(d,"DateTime_Inv_WeekDay", SWIG_From_int((int)(wxDateTime::Inv_WeekDay)));
34278 }
34279 {
34280 PyDict_SetItemString(d,"DateTime_Inv_Year", SWIG_From_int((int)(wxDateTime::Inv_Year)));
34281 }
34282 {
34283 PyDict_SetItemString(d,"DateTime_Name_Full", SWIG_From_int((int)(wxDateTime::Name_Full)));
34284 }
34285 {
34286 PyDict_SetItemString(d,"DateTime_Name_Abbr", SWIG_From_int((int)(wxDateTime::Name_Abbr)));
34287 }
34288 {
34289 PyDict_SetItemString(d,"DateTime_Default_First", SWIG_From_int((int)(wxDateTime::Default_First)));
34290 }
34291 {
34292 PyDict_SetItemString(d,"DateTime_Monday_First", SWIG_From_int((int)(wxDateTime::Monday_First)));
34293 }
34294 {
34295 PyDict_SetItemString(d,"DateTime_Sunday_First", SWIG_From_int((int)(wxDateTime::Sunday_First)));
34296 }
34297 SWIG_addvarlink(SWIG_globals,(char*)"DefaultDateTime",_wrap_DefaultDateTime_get, _wrap_DefaultDateTime_set);
34298 {
34299 PyDict_SetItemString(d,"DF_INVALID", SWIG_From_int((int)(wxDF_INVALID)));
34300 }
34301 {
34302 PyDict_SetItemString(d,"DF_TEXT", SWIG_From_int((int)(wxDF_TEXT)));
34303 }
34304 {
34305 PyDict_SetItemString(d,"DF_BITMAP", SWIG_From_int((int)(wxDF_BITMAP)));
34306 }
34307 {
34308 PyDict_SetItemString(d,"DF_METAFILE", SWIG_From_int((int)(wxDF_METAFILE)));
34309 }
34310 {
34311 PyDict_SetItemString(d,"DF_SYLK", SWIG_From_int((int)(wxDF_SYLK)));
34312 }
34313 {
34314 PyDict_SetItemString(d,"DF_DIF", SWIG_From_int((int)(wxDF_DIF)));
34315 }
34316 {
34317 PyDict_SetItemString(d,"DF_TIFF", SWIG_From_int((int)(wxDF_TIFF)));
34318 }
34319 {
34320 PyDict_SetItemString(d,"DF_OEMTEXT", SWIG_From_int((int)(wxDF_OEMTEXT)));
34321 }
34322 {
34323 PyDict_SetItemString(d,"DF_DIB", SWIG_From_int((int)(wxDF_DIB)));
34324 }
34325 {
34326 PyDict_SetItemString(d,"DF_PALETTE", SWIG_From_int((int)(wxDF_PALETTE)));
34327 }
34328 {
34329 PyDict_SetItemString(d,"DF_PENDATA", SWIG_From_int((int)(wxDF_PENDATA)));
34330 }
34331 {
34332 PyDict_SetItemString(d,"DF_RIFF", SWIG_From_int((int)(wxDF_RIFF)));
34333 }
34334 {
34335 PyDict_SetItemString(d,"DF_WAVE", SWIG_From_int((int)(wxDF_WAVE)));
34336 }
34337 {
34338 PyDict_SetItemString(d,"DF_UNICODETEXT", SWIG_From_int((int)(wxDF_UNICODETEXT)));
34339 }
34340 {
34341 PyDict_SetItemString(d,"DF_ENHMETAFILE", SWIG_From_int((int)(wxDF_ENHMETAFILE)));
34342 }
34343 {
34344 PyDict_SetItemString(d,"DF_FILENAME", SWIG_From_int((int)(wxDF_FILENAME)));
34345 }
34346 {
34347 PyDict_SetItemString(d,"DF_LOCALE", SWIG_From_int((int)(wxDF_LOCALE)));
34348 }
34349 {
34350 PyDict_SetItemString(d,"DF_PRIVATE", SWIG_From_int((int)(wxDF_PRIVATE)));
34351 }
34352 {
34353 PyDict_SetItemString(d,"DF_HTML", SWIG_From_int((int)(wxDF_HTML)));
34354 }
34355 {
34356 PyDict_SetItemString(d,"DF_MAX", SWIG_From_int((int)(wxDF_MAX)));
34357 }
34358 SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
34359 {
34360 PyDict_SetItemString(d,"DataObject_Get", SWIG_From_int((int)(wxDataObject::Get)));
34361 }
34362 {
34363 PyDict_SetItemString(d,"DataObject_Set", SWIG_From_int((int)(wxDataObject::Set)));
34364 }
34365 {
34366 PyDict_SetItemString(d,"DataObject_Both", SWIG_From_int((int)(wxDataObject::Both)));
34367 }
34368 {
34369 PyDict_SetItemString(d,"Drag_CopyOnly", SWIG_From_int((int)(wxDrag_CopyOnly)));
34370 }
34371 {
34372 PyDict_SetItemString(d,"Drag_AllowMove", SWIG_From_int((int)(wxDrag_AllowMove)));
34373 }
34374 {
34375 PyDict_SetItemString(d,"Drag_DefaultMove", SWIG_From_int((int)(wxDrag_DefaultMove)));
34376 }
34377 {
34378 PyDict_SetItemString(d,"DragError", SWIG_From_int((int)(wxDragError)));
34379 }
34380 {
34381 PyDict_SetItemString(d,"DragNone", SWIG_From_int((int)(wxDragNone)));
34382 }
34383 {
34384 PyDict_SetItemString(d,"DragCopy", SWIG_From_int((int)(wxDragCopy)));
34385 }
34386 {
34387 PyDict_SetItemString(d,"DragMove", SWIG_From_int((int)(wxDragMove)));
34388 }
34389 {
34390 PyDict_SetItemString(d,"DragLink", SWIG_From_int((int)(wxDragLink)));
34391 }
34392 {
34393 PyDict_SetItemString(d,"DragCancel", SWIG_From_int((int)(wxDragCancel)));
34394 }
34395
34396 wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
34397 wxPyPtrTypeMap_Add("wxDropTarget", "wxPyDropTarget");
34398 wxPyPtrTypeMap_Add("wxTextDropTarget", "wxPyTextDropTarget");
34399 wxPyPtrTypeMap_Add("wxFileDropTarget", "wxPyFileDropTarget");
34400
34401 SWIG_addvarlink(SWIG_globals,(char*)"DefaultVideoMode",_wrap_DefaultVideoMode_get, _wrap_DefaultVideoMode_set);
34402 }
34403
wxWidgets (Impactor)